From 2be5370dc9b480373f1bb6f14247019453378e33 Mon Sep 17 00:00:00 2001 From: Antoine Wecxsteen Date: Thu, 15 Jul 2021 21:59:00 +0200 Subject: [PATCH 01/10] multiprocessing --- library/multiprocessing.po | 50 ++++++++++++++++++++------------------ 1 file changed, 27 insertions(+), 23 deletions(-) diff --git a/library/multiprocessing.po b/library/multiprocessing.po index f88126398..8636f27f3 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -6,14 +6,14 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2021-01-27 19:26+0100\n" -"PO-Revision-Date: 2020-08-22 12:43+0200\n" -"Last-Translator: Mathieu Dupuy \n" +"PO-Revision-Date: 2021-07-15 19:23+0200\n" +"Last-Translator: Antoine Wecxsteen\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.4.1\n" +"X-Generator: Poedit 2.3\n" #: library/multiprocessing.rst:2 msgid ":mod:`multiprocessing` --- Process-based parallelism" @@ -28,7 +28,6 @@ msgid "Introduction" msgstr "Introduction" #: library/multiprocessing.rst:14 -#, fuzzy msgid "" ":mod:`multiprocessing` is a package that supports spawning processes using " "an API similar to the :mod:`threading` module. The :mod:`multiprocessing` " @@ -40,12 +39,12 @@ msgid "" msgstr "" ":mod:`multiprocessing` est un paquet qui permet l'instanciation de processus " "via la même API que le module :mod:`threading`. Le paquet :mod:" -"`multiprocessing` offre à la fois des possibilités de programmation " -"concurrente locale ou à distance, contournant les problèmes du :term:`Global " +"`multiprocessing` permet la programmation concurrente sur une même machine " +"ou entre machines. Il permet de contourner les problèmes du :term:`Global " "Interpreter Lock` en utilisant des processus plutôt que des fils " "d'exécution. Ainsi, le module :mod:`multiprocessing` permet au développeur " -"de bénéficier entièrement des multiples processeurs sur une machine. Il " -"tourne à la fois sur les systèmes Unix et Windows." +"d'exploiter au mieux tous les processeurs d'une machine. Il tourne à la fois " +"sur les systèmes Unix et Windows." #: library/multiprocessing.rst:23 msgid "" @@ -120,7 +119,6 @@ msgid "*spawn*" msgstr "*spawn*" #: library/multiprocessing.rst:99 -#, fuzzy msgid "" "The parent process starts a fresh python interpreter process. The child " "process will only inherit those resources necessary to run the process " @@ -194,7 +192,7 @@ msgid "" "method should be considered unsafe as it can lead to crashes of the " "subprocess. See :issue:`33725`." msgstr "" -"sur macOS, la méthode de démarrage *spawn* est maintenant la méthode par " +"Sur macOS, la méthode de démarrage *spawn* est maintenant la méthode par " "défaut. La méthode de démarrage *fork* doit être considérée comme dangereuse " "car elle peut entraîner des plantages du sous-processus. Voir :issue:`33725`." @@ -3277,12 +3275,12 @@ msgstr "" "plus, *func* est exécutée sur un seul des *workers* du pool." #: library/multiprocessing.rst:2177 -#, fuzzy msgid "" "A variant of the :meth:`apply` method which returns a :class:" "`~multiprocessing.pool.AsyncResult` object." msgstr "" -"Une variante de la méthode :meth:`apply` qui renvoie un objet résultat." +"Une variante de la méthode :meth:`apply` qui renvoie un objet :class:" +"`~multiprocessing.pool.AsyncResult`." #: library/multiprocessing.rst:2180 library/multiprocessing.rst:2211 msgid "" @@ -3346,11 +3344,12 @@ msgstr "" "efficacité." #: library/multiprocessing.rst:2208 -#, fuzzy msgid "" "A variant of the :meth:`.map` method which returns a :class:" "`~multiprocessing.pool.AsyncResult` object." -msgstr "Une variante de la méthode :meth:`.map` qui renvoie un objet résultat." +msgstr "" +"Une variante de la méthode :meth:`.map` qui renvoie un objet :class:" +"`~multiprocessing.pool.AsyncResult." #: library/multiprocessing.rst:2225 msgid "A lazier version of :meth:`.map`." @@ -3828,17 +3827,17 @@ msgstr "" "le système de fichiers." #: library/multiprocessing.rst:2571 -#, fuzzy msgid "" "An ``'AF_PIPE'`` address is a string of the form :samp:`r'\\\\\\\\.\\\\pipe\\" "\\{PipeName}'`. To use :func:`Client` to connect to a named pipe on a " "remote computer called *ServerName* one should use an address of the form :" "samp:`r'\\\\\\\\{ServerName}\\\\pipe\\\\{PipeName}'` instead." msgstr "" -":samp:`r'\\\\\\\\.\\\\pipe\\\\{PipeName}'`. Pour utiliser un :func:`Client` " -"pour se connecter à un tube nommé sur une machine distante appelée " -"*ServerName*, il faut plutôt utiliser une adresse de la forme :samp:`r'\\\\\\" -"\\{ServerName}\\\\pipe\\\\{PipeName}'`." +"Une adresse ``'AF_PIPE'`` est une chaîne de caractères de la forme :samp:" +"`r'\\\\\\\\.\\\\pipe\\\\{PipeName}'`. Pour utiliser :func:`Client` pour se " +"connecter à un tube nommé sur une machine distante appelée *ServerName*, il " +"faut utiliser une adresse de la forme :samp:`r'\\\\\\\\{ServerName}\\\\pipe\\" +"\\{PipeName}'`." #: library/multiprocessing.rst:2576 msgid "" @@ -3982,7 +3981,7 @@ msgid "" "but is no more than a wrapper around the :mod:`threading` module." msgstr "" ":mod:`multiprocessing.dummy` réplique toute l'API de :mod:`multiprocessing` " -"mais n'est rien de plus qu'un *wrapper* autour du module :mod:`threading`." +"mais n'est rien de plus qu'une interface autour du module :mod:`threading`." #: library/multiprocessing.rst:2666 msgid "" @@ -3991,6 +3990,10 @@ msgid "" "class:`Pool` that supports all the same method calls but uses a pool of " "worker threads rather than worker processes." msgstr "" +"En particulier, la fonction ``Pool`` du module :mod:`multiprocessing.dummy` " +"renvoie une instance de :class:`ThreadPool`, qui est une sous-classe de :" +"class:`Pool`. Elle a la même interface, mais elle utilise un pool de fils " +"d'exécution plutôt qu'un pool de processus." #: library/multiprocessing.rst:2674 msgid "" @@ -4003,18 +4006,19 @@ msgid "" msgstr "" #: library/multiprocessing.rst:2681 -#, fuzzy msgid "" "*processes* is the number of worker threads to use. If *processes* is " "``None`` then the number returned by :func:`os.cpu_count` is used." msgstr "" -"*processes* est le nombre de processus *workers* à utiliser. Si *processes* " -"est ``None``, le nombre renvoyé par :func:`os.cpu_count` est utilisé." +"*processes* est le nombre de fils d'exécution à utiliser. Si *processes* est " +"``None``, le nombre renvoyé par :func:`os.cpu_count` est utilisé." #: library/multiprocessing.rst:2687 msgid "" "Unlike :class:`Pool`, *maxtasksperchild* and *context* cannot be provided." msgstr "" +"À la différence de :class:`Pool`, *maxtasksperchild* et *context* ne peuvent " +"pas être passés en arguments." #: library/multiprocessing.rst:2691 msgid "" From f69b3ea863771466dedaa3177bf6292eb4841cbc Mon Sep 17 00:00:00 2001 From: Antoine Wecxsteen Date: Sat, 17 Jul 2021 15:49:54 +0200 Subject: [PATCH 02/10] =?UTF-8?q?relecture=20achev=C3=A9e?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/multiprocessing.po | 4169 +++++++++------------- library/multiprocessing.shared_memory.po | 6 +- 2 files changed, 1665 insertions(+), 2510 deletions(-) diff --git a/library/multiprocessing.po b/library/multiprocessing.po index 8636f27f3..3e2b5c69c 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -6,7 +6,7 @@ msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2021-01-27 19:26+0100\n" -"PO-Revision-Date: 2021-07-15 19:23+0200\n" +"PO-Revision-Date: 2021-07-16 22:51+0200\n" "Last-Translator: Antoine Wecxsteen\n" "Language-Team: FRENCH \n" "Language: fr\n" @@ -29,43 +29,34 @@ msgstr "Introduction" #: library/multiprocessing.rst:14 msgid "" -":mod:`multiprocessing` is a package that supports spawning processes using " -"an API similar to the :mod:`threading` module. The :mod:`multiprocessing` " -"package offers both local and remote concurrency, effectively side-stepping " -"the :term:`Global Interpreter Lock ` by using " -"subprocesses instead of threads. Due to this, the :mod:`multiprocessing` " -"module allows the programmer to fully leverage multiple processors on a " -"given machine. It runs on both Unix and Windows." -msgstr "" -":mod:`multiprocessing` est un paquet qui permet l'instanciation de processus " -"via la même API que le module :mod:`threading`. Le paquet :mod:" -"`multiprocessing` permet la programmation concurrente sur une même machine " -"ou entre machines. Il permet de contourner les problèmes du :term:`Global " -"Interpreter Lock` en utilisant des processus plutôt que des fils " -"d'exécution. Ainsi, le module :mod:`multiprocessing` permet au développeur " -"d'exploiter au mieux tous les processeurs d'une machine. Il tourne à la fois " -"sur les systèmes Unix et Windows." +":mod:`multiprocessing` is a package that supports spawning processes using an API similar to the :mod:`threading` " +"module. The :mod:`multiprocessing` package offers both local and remote concurrency, effectively side-stepping " +"the :term:`Global Interpreter Lock ` by using subprocesses instead of threads. Due to " +"this, the :mod:`multiprocessing` module allows the programmer to fully leverage multiple processors on a given " +"machine. It runs on both Unix and Windows." +msgstr "" +":mod:`multiprocessing` est un paquet qui permet l'instanciation de processus via la même API que le module :mod:" +"`threading`. Le paquet :mod:`multiprocessing` permet la programmation concurrente sur une même machine ou entre " +"machines. Il permet de contourner les problèmes du :term:`verrou global de l'interpréteur (GIL) ` en utilisant des processus plutôt que des fils d'exécution. Ainsi, le module :mod:" +"`multiprocessing` permet au développeur d'exploiter au mieux tous les processeurs d'une machine. Il tourne à la " +"fois sur les systèmes Unix et Windows." #: library/multiprocessing.rst:23 msgid "" -"The :mod:`multiprocessing` module also introduces APIs which do not have " -"analogs in the :mod:`threading` module. A prime example of this is the :" -"class:`~multiprocessing.pool.Pool` object which offers a convenient means of " -"parallelizing the execution of a function across multiple input values, " -"distributing the input data across processes (data parallelism). The " -"following example demonstrates the common practice of defining such " -"functions in a module so that child processes can successfully import that " -"module. This basic example of data parallelism using :class:" -"`~multiprocessing.pool.Pool`, ::" -msgstr "" -"Le module :mod:`multiprocessing` introduit aussi des API sans analogues dans " -"le module :mod:`threading`. Un exemple est l'objet :class:`~multiprocessing." -"pool.Pool` qui offre une manière pratique de paralléliser l'exécution d'une " -"fonction sur de multiples valeurs d'entrée, distribuant ces valeurs entre " -"les processus (parallélisme de données). L'exemple suivant présente la " -"manière classique de définir une telle fonction dans un module afin que les " -"processus fils puissent importer ce module avec succès. Cet exemple basique " -"de parallélisme de données, utilisant :class:`~multiprocessing.pool.Pool`, ::" +"The :mod:`multiprocessing` module also introduces APIs which do not have analogs in the :mod:`threading` module. " +"A prime example of this is the :class:`~multiprocessing.pool.Pool` object which offers a convenient means of " +"parallelizing the execution of a function across multiple input values, distributing the input data across " +"processes (data parallelism). The following example demonstrates the common practice of defining such functions " +"in a module so that child processes can successfully import that module. This basic example of data parallelism " +"using :class:`~multiprocessing.pool.Pool`, ::" +msgstr "" +"Le module :mod:`multiprocessing` introduit aussi des API sans analogues dans le module :mod:`threading`. Un " +"exemple est l'objet :class:`~multiprocessing.pool.Pool` qui offre un moyen simple de paralléliser l'exécution " +"d'une fonction sur plusieurs valeurs d'entrée, en distribuant ces valeurs entre les processus (parallélisme de " +"données). L'exemple suivant présente la manière classique de définir une telle fonction dans un module afin que " +"les processus fils puissent importer ce module avec succès. Cet exemple basique de parallélisme de données, " +"utilisant :class:`~multiprocessing.pool.Pool`, ::" #: library/multiprocessing.rst:41 msgid "will print to standard output ::" @@ -77,30 +68,25 @@ msgstr "La classe :class:`Process`" #: library/multiprocessing.rst:49 msgid "" -"In :mod:`multiprocessing`, processes are spawned by creating a :class:" -"`Process` object and then calling its :meth:`~Process.start` method. :class:" -"`Process` follows the API of :class:`threading.Thread`. A trivial example " -"of a multiprocess program is ::" +"In :mod:`multiprocessing`, processes are spawned by creating a :class:`Process` object and then calling its :meth:" +"`~Process.start` method. :class:`Process` follows the API of :class:`threading.Thread`. A trivial example of a " +"multiprocess program is ::" msgstr "" -"Dans le module :mod:`multiprocessing`, les processus sont instanciés en " -"créant un objet :class:`Process` et en appelant sa méthode :meth:`~Process." -"start`. La classe :class:`Process` suit la même API que :class:`threading." +"Dans le module :mod:`multiprocessing`, les processus sont instanciés en créant un objet :class:`Process` et en " +"appelant sa méthode :meth:`~Process.start`. La classe :class:`Process` suit la même API que :class:`threading." "Thread`. Un exemple trivial d'un programme multi-processus est ::" #: library/multiprocessing.rst:64 -msgid "" -"To show the individual process IDs involved, here is an expanded example::" -msgstr "" -"Pour afficher les IDs des processus impliqués, voici un exemple plus " -"étoffé ::" +msgid "To show the individual process IDs involved, here is an expanded example::" +msgstr "Pour afficher les IDs des processus impliqués, voici un exemple plus étoffé ::" #: library/multiprocessing.rst:85 msgid "" -"For an explanation of why the ``if __name__ == '__main__'`` part is " -"necessary, see :ref:`multiprocessing-programming`." +"For an explanation of why the ``if __name__ == '__main__'`` part is necessary, see :ref:`multiprocessing-" +"programming`." msgstr "" -"La nécessité de la ligne ``if __name__ == '__main__'`` est expliquée par :" -"ref:`multiprocessing-programming`." +"La nécessité de la ligne ``if __name__ == '__main__'`` est expliquée dans la section :ref:`multiprocessing-" +"programming`." #: library/multiprocessing.rst:91 msgid "Contexts and start methods" @@ -108,11 +94,11 @@ msgstr "Contextes et méthodes de démarrage" #: library/multiprocessing.rst:95 msgid "" -"Depending on the platform, :mod:`multiprocessing` supports three ways to " -"start a process. These *start methods* are" +"Depending on the platform, :mod:`multiprocessing` supports three ways to start a process. These *start methods* " +"are" msgstr "" -"Suivant la plateforme, :mod:`multiprocessing` gère trois manières de " -"démarrer un processus. Ces *méthodes de démarrage* sont" +"Selon la plateforme, :mod:`multiprocessing` gère trois manières de démarrer un processus. Ces *méthodes de " +"démarrage* sont" #: library/multiprocessing.rst:106 msgid "*spawn*" @@ -120,19 +106,15 @@ msgstr "*spawn*" #: library/multiprocessing.rst:99 msgid "" -"The parent process starts a fresh python interpreter process. The child " -"process will only inherit those resources necessary to run the process " -"object's :meth:`~Process.run` method. In particular, unnecessary file " -"descriptors and handles from the parent process will not be inherited. " -"Starting a process using this method is rather slow compared to using *fork* " -"or *forkserver*." +"The parent process starts a fresh python interpreter process. The child process will only inherit those " +"resources necessary to run the process object's :meth:`~Process.run` method. In particular, unnecessary file " +"descriptors and handles from the parent process will not be inherited. Starting a process using this method is " +"rather slow compared to using *fork* or *forkserver*." msgstr "" -"Le processus parent démarre un processus neuf avec un interpréteur Python. " -"Le processus fils hérite uniquement des ressources nécessaires pour exécuter " -"la méthode :meth:`~Process.run` de l'objet associé au processus. En " -"particulier, les descripteurs de fichiers superflus et gérés par le " -"processus parent ne sont pas hérités. Démarrer un processus en utilisant " -"cette méthode est plutôt lent par rapport à *fork* ou *forkserver*." +"Le processus parent démarre un processus neuf avec un interpréteur Python. Le processus fils hérite uniquement " +"des ressources nécessaires pour exécuter la méthode :meth:`~Process.run` de l'objet associé au processus. En " +"particulier, les descripteurs de fichiers superflus et gérés par le processus parent ne sont pas hérités. " +"Démarrer un processus en utilisant cette méthode est plutôt lent par rapport à *fork* ou *forkserver*." #: library/multiprocessing.rst:106 msgid "Available on Unix and Windows. The default on Windows and macOS." @@ -144,16 +126,13 @@ msgstr "*fork*" #: library/multiprocessing.rst:109 msgid "" -"The parent process uses :func:`os.fork` to fork the Python interpreter. The " -"child process, when it begins, is effectively identical to the parent " -"process. All resources of the parent are inherited by the child process. " +"The parent process uses :func:`os.fork` to fork the Python interpreter. The child process, when it begins, is " +"effectively identical to the parent process. All resources of the parent are inherited by the child process. " "Note that safely forking a multithreaded process is problematic." msgstr "" -"Le processus parent utilise :func:`os.fork` pour *forker* l'interpréteur " -"Python. Le processus fils, quand il démarre, est effectivement identique au " -"processus parent. Toutes les ressources du parent sont héritées par le fils. " -"Notez qu'il est problématique de *forker* sans danger un processus *multi-" -"threadé*." +"Le processus parent utilise :func:`os.fork` pour *forker* l'interpréteur Python. Le processus fils, quand il " +"démarre, est effectivement identique au processus parent. Toutes les ressources du parent sont héritées par le " +"fils. Notez qu'il est problématique de *forker* sans danger un processus *multi-threadé*." #: library/multiprocessing.rst:115 msgid "Available on Unix only. The default on Unix." @@ -165,163 +144,126 @@ msgstr "*forkserver*" #: library/multiprocessing.rst:118 msgid "" -"When the program starts and selects the *forkserver* start method, a server " -"process is started. From then on, whenever a new process is needed, the " -"parent process connects to the server and requests that it fork a new " -"process. The fork server process is single threaded so it is safe for it to " -"use :func:`os.fork`. No unnecessary resources are inherited." +"When the program starts and selects the *forkserver* start method, a server process is started. From then on, " +"whenever a new process is needed, the parent process connects to the server and requests that it fork a new " +"process. The fork server process is single threaded so it is safe for it to use :func:`os.fork`. No unnecessary " +"resources are inherited." msgstr "" -"Quand le programme démarre et choisit la méthode de démarrage *forkserver*, " -"un processus serveur est lancé. Dès lors, chaque fois qu'un nouveau " -"processus est nécessaire, le processus parent se connecte au serveur et lui " -"demande de *forker* un nouveau processus. Le processus serveur de *fork* " -"n'utilisant qu'un seul fil d'exécution, il peut utiliser :func:`os.fork` " -"sans danger. Les ressources superflues ne sont pas héritées." +"Quand le programme démarre et choisit la méthode de démarrage *forkserver*, un processus serveur est lancé. Dès " +"lors, chaque fois qu'un nouveau processus est nécessaire, le processus parent se connecte au serveur et lui " +"demande de *forker* un nouveau processus. Le processus serveur de *fork* n'utilisant qu'un seul fil d'exécution, " +"il peut utiliser :func:`os.fork` sans danger. Les ressources superflues ne sont pas héritées." #: library/multiprocessing.rst:125 -msgid "" -"Available on Unix platforms which support passing file descriptors over Unix " -"pipes." +msgid "Available on Unix platforms which support passing file descriptors over Unix pipes." msgstr "" -"Disponible sur les plateformes Unix qui acceptent le passage de descripteurs " -"de fichiers à travers des tubes (*pipes*) Unix." +"Disponible sur les plateformes Unix qui acceptent le passage de descripteurs de fichiers à travers des tubes " +"(*pipes*) Unix." #: library/multiprocessing.rst:130 msgid "" -"On macOS, the *spawn* start method is now the default. The *fork* start " -"method should be considered unsafe as it can lead to crashes of the " -"subprocess. See :issue:`33725`." +"On macOS, the *spawn* start method is now the default. The *fork* start method should be considered unsafe as it " +"can lead to crashes of the subprocess. See :issue:`33725`." msgstr "" -"Sur macOS, la méthode de démarrage *spawn* est maintenant la méthode par " -"défaut. La méthode de démarrage *fork* doit être considérée comme dangereuse " -"car elle peut entraîner des plantages du sous-processus. Voir :issue:`33725`." +"sur macOS, la méthode de démarrage *spawn* est maintenant la méthode par défaut. La méthode de démarrage *fork* " +"doit être considérée comme dangereuse car elle peut entraîner des plantages du sous-processus. Voir :issue:" +"`33725`." #: library/multiprocessing.rst:134 msgid "" -"*spawn* added on all unix platforms, and *forkserver* added for some unix " -"platforms. Child processes no longer inherit all of the parents inheritable " -"handles on Windows." +"*spawn* added on all unix platforms, and *forkserver* added for some unix platforms. Child processes no longer " +"inherit all of the parents inheritable handles on Windows." msgstr "" -"*spawn* ajouté à toutes les plateformes Unix, et *forkserver* ajouté à " -"certaines plateformes Unix. Les processus fils n'héritent plus de tous les " -"descripteurs héritables du parent sous Windows." +"ajout de *spawn* à toutes les plateformes Unix et ajout de *forkserver* à certaines plateformes Unix. Les " +"processus fils n'héritent plus de tous les descripteurs héritables du parent sous Windows." #: library/multiprocessing.rst:140 msgid "" -"On Unix using the *spawn* or *forkserver* start methods will also start a " -"*resource tracker* process which tracks the unlinked named system resources " -"(such as named semaphores or :class:`~multiprocessing.shared_memory." -"SharedMemory` objects) created by processes of the program. When all " -"processes have exited the resource tracker unlinks any remaining tracked " -"object. Usually there should be none, but if a process was killed by a " -"signal there may be some \"leaked\" resources. (Neither leaked semaphores " -"nor shared memory segments will be automatically unlinked until the next " -"reboot. This is problematic for both objects because the system allows only " -"a limited number of named semaphores, and shared memory segments occupy some " -"space in the main memory.)" -msgstr "" -"Sous Unix, utiliser les méthodes de démarrage *spawn* ou *forkserver* " -"démarre aussi un processus de *suivi de ressources* qui détecte les " -"ressources systèmes non-libérées (comme des sémaphores nommés ou des objets :" -"class:`~multiprocessing.shared_memory.SharedMemory`) créés par les processus " -"du programme. Quand tous les processus sont terminés, le traqueur de " -"ressources libère tous les objets restants. Normalement, il ne devrait pas y " -"en avoir, mais si un processus a été tué par un signal, certaines ressources " -"peuvent avoir été « perdues ». Ni les sémaphores ni les blocs de mémoire " -"partagée ne sont libérés avant le prochain redémarrage. C'est problématique " -"dans les deux cas car le système n'autorise qu'un nombre limité de " -"sémaphores et parce que les blocs de mémoire partagée prennent de la place " -"dans la mémoire principale." +"On Unix using the *spawn* or *forkserver* start methods will also start a *resource tracker* process which tracks " +"the unlinked named system resources (such as named semaphores or :class:`~multiprocessing.shared_memory." +"SharedMemory` objects) created by processes of the program. When all processes have exited the resource tracker " +"unlinks any remaining tracked object. Usually there should be none, but if a process was killed by a signal there " +"may be some \"leaked\" resources. (Neither leaked semaphores nor shared memory segments will be automatically " +"unlinked until the next reboot. This is problematic for both objects because the system allows only a limited " +"number of named semaphores, and shared memory segments occupy some space in the main memory.)" +msgstr "" +"Sous Unix, utiliser les méthodes de démarrage *spawn* ou *forkserver* démarre aussi un processus de *suivi de " +"ressources* qui détecte les ressources systèmes non-libérées (comme des sémaphores nommés ou des objets :class:" +"`~multiprocessing.shared_memory.SharedMemory`) créés par les processus du programme. Quand tous les processus " +"sont terminés, le traqueur de ressources libère tous les objets restants. Normalement, il ne devrait pas y en " +"avoir, mais si un processus a été tué par un signal, certaines ressources peuvent avoir été « perdues ». Ni les " +"sémaphores ni les blocs de mémoire partagée ne sont libérés avant le prochain redémarrage. C'est problématique " +"dans les deux cas car le système n'autorise qu'un nombre limité de sémaphores et parce que les blocs de mémoire " +"partagée prennent de la place dans la mémoire principale." #: library/multiprocessing.rst:153 msgid "" -"To select a start method you use the :func:`set_start_method` in the ``if " -"__name__ == '__main__'`` clause of the main module. For example::" +"To select a start method you use the :func:`set_start_method` in the ``if __name__ == '__main__'`` clause of the " +"main module. For example::" msgstr "" -"Pour sélectionner une méthode de démarrage, utilisez la fonction :func:" -"`set_start_method` dans la clause ``if __name__ == '__main__'`` du module " -"principal. Par exemple ::" +"Pour sélectionner une méthode de démarrage, utilisez la fonction :func:`set_start_method` dans la clause ``if " +"__name__ == '__main__'`` du module principal. Par exemple ::" #: library/multiprocessing.rst:170 -msgid "" -":func:`set_start_method` should not be used more than once in the program." -msgstr "" -":func:`set_start_method` ne doit pas être utilisée plus d'une fois dans le " -"programme." +msgid ":func:`set_start_method` should not be used more than once in the program." +msgstr ":func:`set_start_method` ne doit pas être utilisée plus d'une fois dans le programme." #: library/multiprocessing.rst:173 msgid "" -"Alternatively, you can use :func:`get_context` to obtain a context object. " -"Context objects have the same API as the multiprocessing module, and allow " -"one to use multiple start methods in the same program. ::" +"Alternatively, you can use :func:`get_context` to obtain a context object. Context objects have the same API as " +"the multiprocessing module, and allow one to use multiple start methods in the same program. ::" msgstr "" -"Alternativement, vous pouvez utiliser :func:`get_context` pour obtenir un " -"contexte. Les contextes ont la même API que le module *multiprocessing*, et " -"permettent l'utilisation de plusieurs méthodes de démarrage dans un même " +"Alternativement, vous pouvez utiliser :func:`get_context` pour obtenir un contexte. Les contextes ont la même API " +"que le module *multiprocessing*, et permettent l'utilisation de plusieurs méthodes de démarrage dans un même " "programme. ::" #: library/multiprocessing.rst:191 msgid "" -"Note that objects related to one context may not be compatible with " -"processes for a different context. In particular, locks created using the " -"*fork* context cannot be passed to processes started using the *spawn* or " +"Note that objects related to one context may not be compatible with processes for a different context. In " +"particular, locks created using the *fork* context cannot be passed to processes started using the *spawn* or " "*forkserver* start methods." msgstr "" -"Notez que les objets relatifs à un contexte ne sont pas forcément " -"compatibles avec les processus d'un contexte différent. En particulier, les " -"verrous créés avec le contexte *fork* ne peuvent pas être passés aux " -"processus lancés avec les méthodes *spawn* ou *forkserver*." +"Notez que les objets relatifs à un contexte ne sont pas forcément compatibles avec les processus d'un contexte " +"différent. En particulier, les verrous créés avec le contexte *fork* ne peuvent pas être passés aux processus " +"lancés avec les méthodes *spawn* ou *forkserver*." #: library/multiprocessing.rst:196 msgid "" -"A library which wants to use a particular start method should probably use :" -"func:`get_context` to avoid interfering with the choice of the library user." +"A library which wants to use a particular start method should probably use :func:`get_context` to avoid " +"interfering with the choice of the library user." msgstr "" -"Une bibliothèque qui veut utiliser une méthode de démarrage particulière " -"devrait probablement faire appel à :func:`get_context` pour éviter " -"d'interférer avec le choix de l'utilisateur de la bibliothèque." +"Une bibliothèque qui veut utiliser une méthode de démarrage particulière devrait probablement faire appel à :func:" +"`get_context` pour éviter d'interférer avec le choix de l'utilisateur de la bibliothèque." #: library/multiprocessing.rst:202 msgid "" -"The ``'spawn'`` and ``'forkserver'`` start methods cannot currently be used " -"with \"frozen\" executables (i.e., binaries produced by packages like " -"**PyInstaller** and **cx_Freeze**) on Unix. The ``'fork'`` start method does " +"The ``'spawn'`` and ``'forkserver'`` start methods cannot currently be used with \"frozen\" executables (i.e., " +"binaries produced by packages like **PyInstaller** and **cx_Freeze**) on Unix. The ``'fork'`` start method does " "work." msgstr "" -"Les méthodes de démarrage ``’spawn’`` et ``’forkserver’`` ne peuvent pas " -"être utilisées avec des exécutables « figés » (c'est-à-dire des binaires " -"produits par des paquets comme **PyInstaller** et **cx_Freeze**) sur Unix. " -"La méthode de démarrage ``’fork’`` fonctionne." +"Les méthodes de démarrage ``’spawn’`` et ``’forkserver’`` ne peuvent pas être utilisées avec des exécutables " +"« figés » (c'est-à-dire des binaires produits par des paquets comme **PyInstaller** et **cx_Freeze**) sur Unix. " +"Seule la méthode de démarrage ``’fork’`` fonctionne." #: library/multiprocessing.rst:209 msgid "Exchanging objects between processes" msgstr "Échange d'objets entre les processus" #: library/multiprocessing.rst:211 -msgid "" -":mod:`multiprocessing` supports two types of communication channel between " -"processes:" -msgstr "" -":mod:`multiprocessing` gère deux types de canaux de communication entre les " -"processus :" +msgid ":mod:`multiprocessing` supports two types of communication channel between processes:" +msgstr ":mod:`multiprocessing` gère deux types de canaux de communication entre les processus :" #: library/multiprocessing.rst:214 msgid "**Queues**" -msgstr "**Queues**" +msgstr "**Files** (*queues*)" #: library/multiprocessing.rst:216 -msgid "" -"The :class:`Queue` class is a near clone of :class:`queue.Queue`. For " -"example::" -msgstr "" -"La classe :class:`Queue` est un clone assez proche de :class:`queue.Queue`. " -"Par exemple ::" +msgid "The :class:`Queue` class is a near clone of :class:`queue.Queue`. For example::" +msgstr "La classe :class:`Queue` est un clone assez proche de :class:`queue.Queue`. Par exemple ::" #: library/multiprocessing.rst:231 msgid "Queues are thread and process safe." -msgstr "" -"Les queues peuvent être utilisées par plusieurs fils d'exécution ou " -"processus." +msgstr "Les files peuvent être utilisées par plusieurs fils d'exécution ou processus." #: library/multiprocessing.rst:233 msgid "**Pipes**" @@ -329,27 +271,24 @@ msgstr "**Tubes** (*pipes*)" #: library/multiprocessing.rst:235 msgid "" -"The :func:`Pipe` function returns a pair of connection objects connected by " -"a pipe which by default is duplex (two-way). For example::" +"The :func:`Pipe` function returns a pair of connection objects connected by a pipe which by default is duplex " +"(two-way). For example::" msgstr "" -"La fonction :func:`Pipe` renvoie une paire d'objets de connexion connectés à " -"un tube qui est par défaut duplex (à double sens). Par exemple ::" +"La fonction :func:`Pipe` renvoie une paire d'objets de connexion connectés à un tube qui est par défaut duplex (à " +"double sens). Par exemple ::" #: library/multiprocessing.rst:251 msgid "" -"The two connection objects returned by :func:`Pipe` represent the two ends " -"of the pipe. Each connection object has :meth:`~Connection.send` and :meth:" -"`~Connection.recv` methods (among others). Note that data in a pipe may " -"become corrupted if two processes (or threads) try to read from or write to " -"the *same* end of the pipe at the same time. Of course there is no risk of " -"corruption from processes using different ends of the pipe at the same time." -msgstr "" -"Les deux objets de connexion renvoyés par :func:`Pipe` représentent les deux " -"bouts d'un tube. Chaque objet de connexion possède (entre autres) des " -"méthodes :meth:`~Connection.send` et :meth:`~Connection.recv`. Notez que les " -"données d'un tube peuvent être corrompues si deux processus (ou fils " -"d'exécution) essaient de lire ou d'écrire sur le même bout du tube en même " -"temps. Évidemment il n'y a pas de risque de corruption si les processus " +"The two connection objects returned by :func:`Pipe` represent the two ends of the pipe. Each connection object " +"has :meth:`~Connection.send` and :meth:`~Connection.recv` methods (among others). Note that data in a pipe may " +"become corrupted if two processes (or threads) try to read from or write to the *same* end of the pipe at the " +"same time. Of course there is no risk of corruption from processes using different ends of the pipe at the same " +"time." +msgstr "" +"Les deux objets de connexion renvoyés par :func:`Pipe` représentent les deux bouts d'un tube. Chaque objet de " +"connexion possède (entre autres) des méthodes :meth:`~Connection.send` et :meth:`~Connection.recv`. Notez que les " +"données d'un tube peuvent être corrompues si deux processus (ou fils d'exécution) essaient de lire ou d'écrire " +"sur le même bout du tube en même temps. Évidemment il n'y a pas de risque de corruption si les processus " "utilisent deux bouts différents en même temps." #: library/multiprocessing.rst:261 @@ -358,22 +297,16 @@ msgstr "Synchronisation entre processus" #: library/multiprocessing.rst:263 msgid "" -":mod:`multiprocessing` contains equivalents of all the synchronization " -"primitives from :mod:`threading`. For instance one can use a lock to ensure " -"that only one process prints to standard output at a time::" +":mod:`multiprocessing` contains equivalents of all the synchronization primitives from :mod:`threading`. For " +"instance one can use a lock to ensure that only one process prints to standard output at a time::" msgstr "" -":mod:`multiprocessing` contient des équivalents à toutes les primitives de " -"synchronisation de :mod:`threading`. Par exemple il est possible d'utiliser " -"un verrou pour s'assurer qu'un seul processus à la fois écrit sur la sortie " -"standard ::" +":mod:`multiprocessing` contient des équivalents à toutes les primitives de synchronisation de :mod:`threading`. " +"Par exemple il est possible d'utiliser un verrou pour s'assurer qu'un seul processus à la fois écrit sur la " +"sortie standard ::" #: library/multiprocessing.rst:282 -msgid "" -"Without using the lock output from the different processes is liable to get " -"all mixed up." -msgstr "" -"Sans le verrou, les sorties des différents processus risquent d'être " -"mélangées." +msgid "Without using the lock output from the different processes is liable to get all mixed up." +msgstr "Sans le verrou, les sorties des différents processus risquent d'être mélangées." #: library/multiprocessing.rst:287 msgid "Sharing state between processes" @@ -381,21 +314,19 @@ msgstr "Partager un état entre les processus" #: library/multiprocessing.rst:289 msgid "" -"As mentioned above, when doing concurrent programming it is usually best to " -"avoid using shared state as far as possible. This is particularly true when " -"using multiple processes." +"As mentioned above, when doing concurrent programming it is usually best to avoid using shared state as far as " +"possible. This is particularly true when using multiple processes." msgstr "" -"Comme mentionné plus haut, il est généralement préférable d'éviter autant " -"que possible d'utiliser des états partagés en programmation concurrente. " -"C'est particulièrement vrai quand plusieurs processus sont utilisés." +"Comme mentionné plus haut, il est généralement préférable d'éviter autant que possible d'utiliser des états " +"partagés en programmation concurrente. C'est particulièrement vrai quand plusieurs processus sont utilisés." #: library/multiprocessing.rst:293 msgid "" -"However, if you really do need to use some shared data then :mod:" -"`multiprocessing` provides a couple of ways of doing so." +"However, if you really do need to use some shared data then :mod:`multiprocessing` provides a couple of ways of " +"doing so." msgstr "" -"Cependant, si vous devez réellement partager des données, :mod:" -"`multiprocessing` permet de le faire de deux manières." +"Cependant, si vous devez réellement partager des données, :mod:`multiprocessing` permet de le faire de deux " +"manières." #: library/multiprocessing.rst:296 msgid "**Shared memory**" @@ -403,11 +334,11 @@ msgstr "**Mémoire partagée**" #: library/multiprocessing.rst:298 msgid "" -"Data can be stored in a shared memory map using :class:`Value` or :class:" -"`Array`. For example, the following code ::" +"Data can be stored in a shared memory map using :class:`Value` or :class:`Array`. For example, the following " +"code ::" msgstr "" -"Les données peuvent être stockées dans une mémoire partagée en utilisant " -"des :class:`Value` ou des :class:`Array`. Par exemple, le code suivant ::" +"Les données peuvent être stockées dans une mémoire partagée en utilisant des :class:`Value` ou des :class:" +"`Array`. Par exemple, le code suivant ::" #: library/multiprocessing.rst:319 library/multiprocessing.rst:365 msgid "will print ::" @@ -415,26 +346,22 @@ msgstr "affiche ::" #: library/multiprocessing.rst:324 msgid "" -"The ``'d'`` and ``'i'`` arguments used when creating ``num`` and ``arr`` are " -"typecodes of the kind used by the :mod:`array` module: ``'d'`` indicates a " -"double precision float and ``'i'`` indicates a signed integer. These shared " -"objects will be process and thread-safe." +"The ``'d'`` and ``'i'`` arguments used when creating ``num`` and ``arr`` are typecodes of the kind used by the :" +"mod:`array` module: ``'d'`` indicates a double precision float and ``'i'`` indicates a signed integer. These " +"shared objects will be process and thread-safe." msgstr "" -"Les arguments ``'d'`` et ``'i'`` utilisés à la création des ``num`` et " -"``arr`` sont des codes de types tels qu'utilisés par le module :mod:" -"`array` : ``'d'`` indique un flottant double-précision et ``'i'`` indique un " -"entier signé. Ces objets peuvent être partagés sans problème entre processus " -"ou entre fils d’exécution multiples." +"Les arguments ``'d'`` et ``'i'`` utilisés à la création des ``num`` et ``arr`` sont des codes de types identiques " +"à ceux du module :mod:`array` : ``'d'`` indique un flottant double-précision et ``'i'`` indique un entier signé. " +"Ces objets peuvent être partagés sans problème entre processus ou fils d’exécution." #: library/multiprocessing.rst:329 msgid "" -"For more flexibility in using shared memory one can use the :mod:" -"`multiprocessing.sharedctypes` module which supports the creation of " -"arbitrary ctypes objects allocated from shared memory." +"For more flexibility in using shared memory one can use the :mod:`multiprocessing.sharedctypes` module which " +"supports the creation of arbitrary ctypes objects allocated from shared memory." msgstr "" -"Pour plus de flexibilité dans l'utilisation de mémoire partagée, vous pouvez " -"utiliser le module :mod:`multiprocessing.sharedctypes` qui permet la " -"création d'objets arbitraires *ctypes* alloués depuis la mémoire partagée." +"Pour plus de flexibilité dans l'utilisation de mémoire partagée, vous pouvez utiliser le module :mod:" +"`multiprocessing.sharedctypes` qui permet la création d'objets arbitraires *ctypes* alloués depuis la mémoire " +"partagée." #: library/multiprocessing.rst:333 msgid "**Server process**" @@ -442,102 +369,79 @@ msgstr "**Processus serveur**" #: library/multiprocessing.rst:335 msgid "" -"A manager object returned by :func:`Manager` controls a server process which " -"holds Python objects and allows other processes to manipulate them using " -"proxies." +"A manager object returned by :func:`Manager` controls a server process which holds Python objects and allows " +"other processes to manipulate them using proxies." msgstr "" -"Un objet gestionnaire renvoyé par :func:`Manager` contrôle un processus " -"serveur qui détient les objets Python et autorise les autres processus à les " -"manipuler à l'aide de mandataires." +"Un objet gestionnaire renvoyé par :func:`Manager` contrôle un processus serveur qui détient les objets Python et " +"autorise les autres processus à les manipuler à l'aide de mandataires." #: library/multiprocessing.rst:339 msgid "" -"A manager returned by :func:`Manager` will support types :class:`list`, :" -"class:`dict`, :class:`~managers.Namespace`, :class:`Lock`, :class:`RLock`, :" -"class:`Semaphore`, :class:`BoundedSemaphore`, :class:`Condition`, :class:" -"`Event`, :class:`Barrier`, :class:`Queue`, :class:`Value` and :class:" -"`Array`. For example, ::" +"A manager returned by :func:`Manager` will support types :class:`list`, :class:`dict`, :class:`~managers." +"Namespace`, :class:`Lock`, :class:`RLock`, :class:`Semaphore`, :class:`BoundedSemaphore`, :class:`Condition`, :" +"class:`Event`, :class:`Barrier`, :class:`Queue`, :class:`Value` and :class:`Array`. For example, ::" msgstr "" -"Un gestionnaire renvoyé par :func:`Manager` supportera les types :class:" -"`list`, :class:`dict`, :class:`~managers.Namespace`, :class:`Lock`, :class:" -"`RLock`, :class:`Semaphore`, :class:`BoundedSemaphore`, :class:`Condition`, :" -"class:`Event`, :class:`Barrier`, :class:`Queue`, :class:`Value` et :class:" -"`Array`. Par exemple, ::" +"Un gestionnaire renvoyé par :func:`Manager` prend en charge les types :class:`list`, :class:`dict`, :class:" +"`~managers.Namespace`, :class:`Lock`, :class:`RLock`, :class:`Semaphore`, :class:`BoundedSemaphore`, :class:" +"`Condition`, :class:`Event`, :class:`Barrier`, :class:`Queue`, :class:`Value` et :class:`Array`. Par exemple, ::" #: library/multiprocessing.rst:370 msgid "" -"Server process managers are more flexible than using shared memory objects " -"because they can be made to support arbitrary object types. Also, a single " -"manager can be shared by processes on different computers over a network. " +"Server process managers are more flexible than using shared memory objects because they can be made to support " +"arbitrary object types. Also, a single manager can be shared by processes on different computers over a network. " "They are, however, slower than using shared memory." msgstr "" -"Les processus serveurs de gestionnaires sont plus flexibles que les mémoires " -"partagées parce qu'ils peuvent gérer des types d'objets arbitraires. Aussi, " -"un gestionnaire unique peut être partagé par les processus sur différentes " -"machines à travers le réseau. Cependant, ils sont plus lents que les " -"mémoires partagées." +"Les processus serveurs de gestionnaires sont plus flexibles que les mémoires partagées parce qu'ils peuvent gérer " +"des types d'objets arbitraires. Aussi, un gestionnaire unique peut être partagé par les processus sur différentes " +"machines à travers le réseau. Cependant, ils sont plus lents que les mémoires partagées." #: library/multiprocessing.rst:377 msgid "Using a pool of workers" -msgstr "Utiliser un réservoir de *workers*" +msgstr "Utiliser un pool de *workers*" #: library/multiprocessing.rst:379 msgid "" -"The :class:`~multiprocessing.pool.Pool` class represents a pool of worker " -"processes. It has methods which allows tasks to be offloaded to the worker " -"processes in a few different ways." +"The :class:`~multiprocessing.pool.Pool` class represents a pool of worker processes. It has methods which allows " +"tasks to be offloaded to the worker processes in a few different ways." msgstr "" -"La classe :class:`~multiprocessing.pool.Pool` représente une *pool* de " -"processus de travail. Elle possède des méthodes qui permettent aux tâches " -"d'être déchargées vers les processus de travail de différentes manières." +"La classe :class:`~multiprocessing.pool.Pool` représente un pool de processus de travail. Elle possède des " +"méthodes qui permettent aux tâches d'être déchargées vers les processus de travail de différentes manières." #: library/multiprocessing.rst:383 msgid "For example::" msgstr "Par exemple ::" #: library/multiprocessing.rst:427 -msgid "" -"Note that the methods of a pool should only ever be used by the process " -"which created it." -msgstr "" -"Notez que les méthodes d'une *pool* ne devraient être utilisées que par le " -"processus qui l'a créée." +msgid "Note that the methods of a pool should only ever be used by the process which created it." +msgstr "Notez que les méthodes d'une pool ne doivent être utilisées que par le processus qui l'a créée." #: library/multiprocessing.rst:432 msgid "" -"Functionality within this package requires that the ``__main__`` module be " -"importable by the children. This is covered in :ref:`multiprocessing-" -"programming` however it is worth pointing out here. This means that some " -"examples, such as the :class:`multiprocessing.pool.Pool` examples will not " -"work in the interactive interpreter. For example::" +"Functionality within this package requires that the ``__main__`` module be importable by the children. This is " +"covered in :ref:`multiprocessing-programming` however it is worth pointing out here. This means that some " +"examples, such as the :class:`multiprocessing.pool.Pool` examples will not work in the interactive interpreter. " +"For example::" msgstr "" -"Fonctionnellement ce paquet exige que que le module ``__main__`` soit " -"importable par les fils. Cela est expliqué sur la page :ref:`multiprocessing-" -"programming`, il est cependant utile de le rappeler ici. Cela signifie que " -"certains exemples, comme les exemples utilisant :class:`multiprocessing.pool." -"Pool`, ne fonctionnent pas dans l'interpréteur interactif. Par exemple ::" +"Fonctionnellement ce paquet exige que que le module ``__main__`` soit importable par les fils. Cela est expliqué " +"sur la page :ref:`multiprocessing-programming`, il est cependant utile de le rappeler ici. Cela signifie que " +"certains exemples, comme les exemples utilisant :class:`multiprocessing.pool.Pool`, ne fonctionnent pas dans " +"l'interpréteur interactif. Par exemple ::" #: library/multiprocessing.rst:455 msgid "" -"(If you try this it will actually output three full tracebacks interleaved " -"in a semi-random fashion, and then you may have to stop the parent process " -"somehow.)" +"(If you try this it will actually output three full tracebacks interleaved in a semi-random fashion, and then you " +"may have to stop the parent process somehow.)" msgstr "" -"Si vous essayez ce code, il affichera trois traces d'appels complètes " -"entrelacées de manière semi-aléatoire, et vous devrez vous débrouiller pour " -"arrêter le processus maître." +"Si vous essayez ce code, il affichera trois traces d'appels complètes entrelacées de manière semi-aléatoire, et " +"vous devrez vous débrouiller pour arrêter le processus maître." #: library/multiprocessing.rst:461 msgid "Reference" msgstr "Référence" #: library/multiprocessing.rst:463 -msgid "" -"The :mod:`multiprocessing` package mostly replicates the API of the :mod:" -"`threading` module." -msgstr "" -"Le paquet :mod:`multiprocessing` reproduit en grande partie l'API du module :" -"mod:`threading`." +msgid "The :mod:`multiprocessing` package mostly replicates the API of the :mod:`threading` module." +msgstr "Le paquet :mod:`multiprocessing` reproduit en grande partie l'API du module :mod:`threading`." #: library/multiprocessing.rst:468 msgid ":class:`Process` and exceptions" @@ -545,37 +449,29 @@ msgstr ":class:`Process` et exceptions" #: library/multiprocessing.rst:473 msgid "" -"Process objects represent activity that is run in a separate process. The :" -"class:`Process` class has equivalents of all the methods of :class:" -"`threading.Thread`." +"Process objects represent activity that is run in a separate process. The :class:`Process` class has equivalents " +"of all the methods of :class:`threading.Thread`." msgstr "" -"Les objets *process* représentent une activité exécutée dans un processus " -"séparé. La classe :class:`Process` a des équivalents à toutes les méthodes " -"de :class:`threading.Thread`." +"Les objets *process* représentent une activité exécutée dans un processus séparé. La classe :class:`Process` a " +"des équivalents à toutes les méthodes de :class:`threading.Thread`." #: library/multiprocessing.rst:477 msgid "" -"The constructor should always be called with keyword arguments. *group* " -"should always be ``None``; it exists solely for compatibility with :class:" -"`threading.Thread`. *target* is the callable object to be invoked by the :" -"meth:`run()` method. It defaults to ``None``, meaning nothing is called. " -"*name* is the process name (see :attr:`name` for more details). *args* is " -"the argument tuple for the target invocation. *kwargs* is a dictionary of " -"keyword arguments for the target invocation. If provided, the keyword-only " -"*daemon* argument sets the process :attr:`daemon` flag to ``True`` or " -"``False``. If ``None`` (the default), this flag will be inherited from the " +"The constructor should always be called with keyword arguments. *group* should always be ``None``; it exists " +"solely for compatibility with :class:`threading.Thread`. *target* is the callable object to be invoked by the :" +"meth:`run()` method. It defaults to ``None``, meaning nothing is called. *name* is the process name (see :attr:" +"`name` for more details). *args* is the argument tuple for the target invocation. *kwargs* is a dictionary of " +"keyword arguments for the target invocation. If provided, the keyword-only *daemon* argument sets the process :" +"attr:`daemon` flag to ``True`` or ``False``. If ``None`` (the default), this flag will be inherited from the " "creating process." msgstr "" -"Le constructeur doit toujours être appelé avec des arguments nommés. *group* " -"devrait toujours être ``None`` ; il existe uniquement pour la compatibilité " -"avec :class:`threading.Thread`. *target* est l'objet appelable qui est " -"invoqué par la méthode :meth:`run(). Il vaut ``None`` par défaut, signifiant " -"que rien n'est appelé. *name* est le nom du processus (voir :attr:`name` " -"pour plus de détails). *args* est le *n*-uplet d'arguments pour l'invocation " -"de la cible. *kwargs* est le dictionnaire des arguments nommés pour " -"l'invocation de la cible. S'il est fourni, l'argument nommé *daemon* met " -"l'option :attr:`daemon` du processus à ``True`` ou ``False``. S'il est " -"``None`` (par défaut), l'option est héritée par le processus créateur." +"Le constructeur doit toujours être appelé avec des arguments nommés. *group* doit toujours être ``None`` ; il " +"existe uniquement pour la compatibilité avec :class:`threading.Thread`. *target* est l'objet appelable qui est " +"invoqué par la méthode :meth:`run(). Il vaut ``None`` par défaut, signifiant que rien n'est appelé. *name* est le " +"nom du processus (voir :attr:`name` pour plus de détails). *args* est le *n*-uplet d'arguments pour l'invocation " +"de la cible. *kwargs* est le dictionnaire des arguments nommés pour l'invocation de la cible. S'il est fourni, " +"l'argument nommé *daemon* met l'option :attr:`daemon` du processus à ``True`` ou ``False``. S'il est ``None`` " +"(par défaut), l'option est héritée par le processus créateur." #: library/multiprocessing.rst:488 msgid "By default, no arguments are passed to *target*." @@ -583,13 +479,11 @@ msgstr "Par défaut, aucun argument n'est passé à *target*." #: library/multiprocessing.rst:490 msgid "" -"If a subclass overrides the constructor, it must make sure it invokes the " -"base class constructor (:meth:`Process.__init__`) before doing anything else " -"to the process." +"If a subclass overrides the constructor, it must make sure it invokes the base class constructor (:meth:`Process." +"__init__`) before doing anything else to the process." msgstr "" -"Si une sous-classe redéfinit le constructeur, elle doit s'assurer d'invoquer " -"le constructeur de la classe de base (:meth:`Process.__init__`) avant de " -"faire autre chose du processus." +"Si une sous-classe redéfinit le constructeur, elle doit s'assurer d'invoquer le constructeur de la classe de base " +"(:meth:`Process.__init__`) avant de faire autre chose du processus." #: library/multiprocessing.rst:494 msgid "Added the *daemon* argument." @@ -601,14 +495,12 @@ msgstr "Méthode représentant l'activité du processus." #: library/multiprocessing.rst:501 msgid "" -"You may override this method in a subclass. The standard :meth:`run` method " -"invokes the callable object passed to the object's constructor as the target " -"argument, if any, with sequential and keyword arguments taken from the " +"You may override this method in a subclass. The standard :meth:`run` method invokes the callable object passed " +"to the object's constructor as the target argument, if any, with sequential and keyword arguments taken from the " "*args* and *kwargs* arguments, respectively." msgstr "" -"Vous pouvez redéfinir cette méthode dans une sous-classe. La méthode " -"standard :meth:`run` invoque l'objet appelable passé au constructeur comme " -"argument *target*, si fourni, avec les arguments séquentiels et nommés " +"Vous pouvez redéfinir cette méthode dans une sous-classe. La méthode standard :meth:`run` invoque l'objet " +"appelable passé au constructeur comme argument *target*, si fourni, avec les arguments séquentiels et nommés " "respectivement pris depuis les paramètres *args* et *kwargs*." #: library/multiprocessing.rst:508 @@ -617,28 +509,23 @@ msgstr "Démarre l'activité du processus." #: library/multiprocessing.rst:510 msgid "" -"This must be called at most once per process object. It arranges for the " -"object's :meth:`run` method to be invoked in a separate process." +"This must be called at most once per process object. It arranges for the object's :meth:`run` method to be " +"invoked in a separate process." msgstr "" -"Elle doit être appelée au plus une fois par objet processus. Elle s'arrange " -"pour que la méthode :meth:`run` de l'objet soit invoquée dans un processus " -"séparé." +"Elle doit être appelée au plus une fois par objet processus. Elle s'arrange pour que la méthode :meth:`run` de " +"l'objet soit invoquée dans un processus séparé." #: library/multiprocessing.rst:515 msgid "" -"If the optional argument *timeout* is ``None`` (the default), the method " -"blocks until the process whose :meth:`join` method is called terminates. If " -"*timeout* is a positive number, it blocks at most *timeout* seconds. Note " -"that the method returns ``None`` if its process terminates or if the method " -"times out. Check the process's :attr:`exitcode` to determine if it " -"terminated." +"If the optional argument *timeout* is ``None`` (the default), the method blocks until the process whose :meth:" +"`join` method is called terminates. If *timeout* is a positive number, it blocks at most *timeout* seconds. Note " +"that the method returns ``None`` if its process terminates or if the method times out. Check the process's :attr:" +"`exitcode` to determine if it terminated." msgstr "" -"Si l'argument optionnel *timeout* est ``None`` (par défaut), la méthode " -"bloque jusqu'à ce que le processus dont la méthode :meth:`join` a été " -"appelée se termine. Si *timeout* est un nombre positif, elle bloque au " -"maximum pendant *timeout* secondes. Notez que la méthode renvoie ``None`` si " -"le processus se termine ou si le temps d'exécution expire. Vérifiez " -"l'attribut :attr:`exitcode` du processus pour déterminer s'il s'est terminé." +"Si l'argument optionnel *timeout* est ``None`` (par défaut), la méthode bloque jusqu'à ce que le processus dont " +"la méthode :meth:`join` a été appelée se termine. Si *timeout* est un nombre positif, elle bloque au maximum " +"pendant *timeout* secondes. Notez que la méthode renvoie ``None`` si le processus se termine ou si le temps " +"d'exécution expire. Vérifiez l'attribut :attr:`exitcode` du processus pour déterminer s'il s'est terminé." #: library/multiprocessing.rst:522 msgid "A process can be joined many times." @@ -646,32 +533,28 @@ msgstr "*join* peut être appelée plusieurs fois sur un même processus." #: library/multiprocessing.rst:524 msgid "" -"A process cannot join itself because this would cause a deadlock. It is an " -"error to attempt to join a process before it has been started." +"A process cannot join itself because this would cause a deadlock. It is an error to attempt to join a process " +"before it has been started." msgstr "" -"Un processus ne peut pas s'attendre lui-même car cela causerait un " -"interblocage. C'est une erreur d'essayer d'attendre un processus avant qu'il " -"ne soit démarré." +"Un processus ne peut pas s'attendre lui-même car cela causerait un interblocage. C'est une erreur d'essayer " +"d'attendre un processus avant qu'il ne soit démarré." #: library/multiprocessing.rst:529 msgid "" -"The process's name. The name is a string used for identification purposes " -"only. It has no semantics. Multiple processes may be given the same name." +"The process's name. The name is a string used for identification purposes only. It has no semantics. Multiple " +"processes may be given the same name." msgstr "" -"Le nom du processus. Le nom est une chaîne de caractères utilisée uniquement " -"pour l'identification du processus. Il n'a pas de sémantique. Plusieurs " -"processus peuvent avoir le même nom." +"Le nom du processus. Le nom est une chaîne de caractères utilisée uniquement pour l'identification du processus. " +"Il n'a pas de sémantique. Plusieurs processus peuvent avoir le même nom." #: library/multiprocessing.rst:533 msgid "" -"The initial name is set by the constructor. If no explicit name is provided " -"to the constructor, a name of the form 'Process-N\\ :sub:`1`:N\\ :sub:" -"`2`:...:N\\ :sub:`k`' is constructed, where each N\\ :sub:`k` is the N-th " +"The initial name is set by the constructor. If no explicit name is provided to the constructor, a name of the " +"form 'Process-N\\ :sub:`1`:N\\ :sub:`2`:...:N\\ :sub:`k`' is constructed, where each N\\ :sub:`k` is the N-th " "child of its parent." msgstr "" -"Le nom initial est déterminé par le constructeur. Si aucun nom explicite " -"n'est fourni au constructeur, un nom de la forme « Process-N\\ :sub:`1`:N\\ :" -"sub:`2`:...:N\\ :sub:`k` » est construit, où chaque N\\ :sub:`k` est le N\\ :" +"Le nom initial est déterminé par le constructeur. Si aucun nom explicite n'est fourni au constructeur, un nom de " +"la forme « Process-N\\ :sub:`1`:N\\ :sub:`2`:...:N\\ :sub:`k` » est construit, où chaque N\\ :sub:`k` est le N\\ :" "sup:`e` enfant de son parent." #: library/multiprocessing.rst:540 @@ -680,70 +563,57 @@ msgstr "Renvoie vrai si le processus est en vie, faux sinon." #: library/multiprocessing.rst:542 msgid "" -"Roughly, a process object is alive from the moment the :meth:`start` method " -"returns until the child process terminates." +"Roughly, a process object is alive from the moment the :meth:`start` method returns until the child process " +"terminates." msgstr "" -"Grossièrement, un objet processus est en vie depuis le moment où la méthode :" -"meth:`start` finit de s'exécuter jusqu'à ce que le processus fils se termine." +"Grossièrement, un objet processus est en vie depuis le moment où la méthode :meth:`start` finit de s'exécuter " +"jusqu'à ce que le processus fils se termine." #: library/multiprocessing.rst:547 -msgid "" -"The process's daemon flag, a Boolean value. This must be set before :meth:" -"`start` is called." +msgid "The process's daemon flag, a Boolean value. This must be set before :meth:`start` is called." msgstr "" -"L'option *daemon* du processus, une valeur booléenne. L'option doit être " -"réglée avant que la méthode :meth:`start` ne soit appelée." +"L'option *daemon* du processus, une valeur booléenne. L'option doit être réglée avant que la méthode :meth:" +"`start` ne soit appelée." #: library/multiprocessing.rst:550 msgid "The initial value is inherited from the creating process." msgstr "La valeur initiale est héritée par le processus créateur." #: library/multiprocessing.rst:552 -msgid "" -"When a process exits, it attempts to terminate all of its daemonic child " -"processes." -msgstr "" -"Quand un processus se ferme, il tente de terminer tous ses processus enfants " -"*daemon*." +msgid "When a process exits, it attempts to terminate all of its daemonic child processes." +msgstr "Quand un processus se ferme, il tente de terminer tous ses processus enfants *daemon*." #: library/multiprocessing.rst:555 msgid "" -"Note that a daemonic process is not allowed to create child processes. " -"Otherwise a daemonic process would leave its children orphaned if it gets " -"terminated when its parent process exits. Additionally, these are **not** " -"Unix daemons or services, they are normal processes that will be terminated " -"(and not joined) if non-daemonic processes have exited." +"Note that a daemonic process is not allowed to create child processes. Otherwise a daemonic process would leave " +"its children orphaned if it gets terminated when its parent process exits. Additionally, these are **not** Unix " +"daemons or services, they are normal processes that will be terminated (and not joined) if non-daemonic processes " +"have exited." msgstr "" -"Notez qu'un processus *daemon* n'est pas autorisé à créer des processus " -"fils. Sinon un processus *daemon* laisserait ses enfants orphelins lorsqu'il " -"se termine par la fermeture de son parent. De plus, ce **ne sont pas** des " -"*daemons* ou services Unix, ce sont des processus normaux qui seront " -"terminés (et non attendus) si un processus non *daemon* se ferme." +"Notez qu'un processus *daemon* n'est pas autorisé à créer des processus fils. Sinon un processus *daemon* " +"laisserait ses enfants orphelins lorsqu'il se termine par la fermeture de son parent. De plus, ce **ne sont pas** " +"des *daemons* ou services Unix, ce sont des processus normaux qui seront terminés (et non attendus) si un " +"processus non *daemon* se ferme." #: library/multiprocessing.rst:561 msgid "" -"In addition to the :class:`threading.Thread` API, :class:`Process` objects " -"also support the following attributes and methods:" +"In addition to the :class:`threading.Thread` API, :class:`Process` objects also support the following attributes " +"and methods:" msgstr "" -"En plus de l'API :class:`threading.Thread`, les objets :class:`Process` " -"supportent aussi les attributs et méthodes suivants :" +"En plus de l'API :class:`threading.Thread`, les objets :class:`Process` supportent aussi les attributs et " +"méthodes suivants :" #: library/multiprocessing.rst:566 -msgid "" -"Return the process ID. Before the process is spawned, this will be ``None``." -msgstr "" -"Renvoie l'ID du processus. Avant que le processus ne soit lancé, la valeur " -"est ``None``." +msgid "Return the process ID. Before the process is spawned, this will be ``None``." +msgstr "Renvoie l'ID du processus. Avant que le processus ne soit lancé, la valeur est ``None``." #: library/multiprocessing.rst:571 msgid "" -"The child's exit code. This will be ``None`` if the process has not yet " -"terminated. A negative value *-N* indicates that the child was terminated " -"by signal *N*." +"The child's exit code. This will be ``None`` if the process has not yet terminated. A negative value *-N* " +"indicates that the child was terminated by signal *N*." msgstr "" -"Le code de fermeture de l'enfant. La valeur est ``None`` si le processus ne " -"s'est pas encore terminé. Une valeur négative *-N* indique que le fils a été " -"terminé par un signal *N*." +"Le code de retour du fils. La valeur est ``None`` si le processus ne s'est pas encore terminé. Une valeur " +"négative *-N* indique que le fils a été terminé par un signal *N*." #: library/multiprocessing.rst:577 msgid "The process's authentication key (a byte string)." @@ -751,116 +621,89 @@ msgstr "La clé d'authentification du processus (une chaîne d'octets)." #: library/multiprocessing.rst:579 msgid "" -"When :mod:`multiprocessing` is initialized the main process is assigned a " -"random string using :func:`os.urandom`." +"When :mod:`multiprocessing` is initialized the main process is assigned a random string using :func:`os.urandom`." msgstr "" -"Quand :mod:`multiprocessing` est initialisé, une chaîne aléatoire est " -"assignée au processus principal, en utilisant :func:`os.urandom`." +"Quand :mod:`multiprocessing` est initialisé, une chaîne aléatoire est assignée au processus principal, en " +"utilisant :func:`os.urandom`." #: library/multiprocessing.rst:582 msgid "" -"When a :class:`Process` object is created, it will inherit the " -"authentication key of its parent process, although this may be changed by " -"setting :attr:`authkey` to another byte string." +"When a :class:`Process` object is created, it will inherit the authentication key of its parent process, although " +"this may be changed by setting :attr:`authkey` to another byte string." msgstr "" -"Quand un objet :class:`Process` est créé, il hérité de la clé " -"d'authentification de son parent, bien que cela puisse être changé à l'aide " -"du paramètre :attr:`authkey` pour une autre chaîne d'octets." +"Quand un objet :class:`Process` est créé, il hérité de la clé d'authentification de son parent, bien que cela " +"puisse être changé à l'aide du paramètre :attr:`authkey` pour une autre chaîne d'octets." #: library/multiprocessing.rst:586 msgid "See :ref:`multiprocessing-auth-keys`." msgstr "Voir :ref:`multiprocessing-auth-keys`." #: library/multiprocessing.rst:590 -msgid "" -"A numeric handle of a system object which will become \"ready\" when the " -"process ends." -msgstr "" -"Un identifiant numérique de l'objet système qui devient « prêt » quand le " -"processus se termine." +msgid "A numeric handle of a system object which will become \"ready\" when the process ends." +msgstr "Un identifiant numérique de l'objet système qui devient « prêt » quand le processus se termine." #: library/multiprocessing.rst:593 msgid "" -"You can use this value if you want to wait on several events at once using :" -"func:`multiprocessing.connection.wait`. Otherwise calling :meth:`join()` is " -"simpler." +"You can use this value if you want to wait on several events at once using :func:`multiprocessing.connection." +"wait`. Otherwise calling :meth:`join()` is simpler." msgstr "" -"Vous pouvez utiliser cette valeur si vous voulez attendre plusieurs " -"événements à la fois en utilisant :func:`multiprocessing.connection.wait`. " -"Autrement appeler :meth:`join()` est plus simple." +"Vous pouvez utiliser cette valeur si vous voulez attendre plusieurs événements à la fois en utilisant :func:" +"`multiprocessing.connection.wait`. Autrement appeler :meth:`join()` est plus simple." #: library/multiprocessing.rst:597 msgid "" -"On Windows, this is an OS handle usable with the ``WaitForSingleObject`` and " -"``WaitForMultipleObjects`` family of API calls. On Unix, this is a file " -"descriptor usable with primitives from the :mod:`select` module." +"On Windows, this is an OS handle usable with the ``WaitForSingleObject`` and ``WaitForMultipleObjects`` family of " +"API calls. On Unix, this is a file descriptor usable with primitives from the :mod:`select` module." msgstr "" -"Sous Windows, c'est un mécanisme de l'OS utilisable avec les familles " -"d'appels API ``WaitForSingleObject`` et ``WaitForMultipleObjects``. Sous " -"Unix, c'est un descripteur de fichier utilisable avec les primitives sur " -"module :mod:`select`." +"Sous Windows, c'est un mécanisme système utilisable avec les familles d'appels API ``WaitForSingleObject`` et " +"``WaitForMultipleObjects``. Sous Unix, c'est un descripteur de fichier utilisable avec les primitives sur module :" +"mod:`select`." #: library/multiprocessing.rst:605 msgid "" -"Terminate the process. On Unix this is done using the ``SIGTERM`` signal; " -"on Windows :c:func:`TerminateProcess` is used. Note that exit handlers and " -"finally clauses, etc., will not be executed." +"Terminate the process. On Unix this is done using the ``SIGTERM`` signal; on Windows :c:func:`TerminateProcess` " +"is used. Note that exit handlers and finally clauses, etc., will not be executed." msgstr "" -"Termine le processus. Sous Unix cela est réalisé à l'aide d'un signal " -"``SIGTERM``, sous Windows :c:func:`TerminateProcess` est utilisé. Notez que " -"les gestionnaires de sortie, les clauses `finally` etc. ne sont pas " +"Termine le processus. Sous Unix cela est réalisé à l'aide d'un signal ``SIGTERM``, sous Windows :c:func:" +"`TerminateProcess` est utilisé. Notez que les gestionnaires de sortie, les clauses `finally` etc. ne sont pas " "exécutées." #: library/multiprocessing.rst:609 -msgid "" -"Note that descendant processes of the process will *not* be terminated -- " -"they will simply become orphaned." -msgstr "" -"Notez que les descendants du processus ne *seront pas* terminés – ils " -"deviendront simplement orphelins." +msgid "Note that descendant processes of the process will *not* be terminated -- they will simply become orphaned." +msgstr "Notez que les descendants du processus ne sont *pas* terminés – ils deviendront simplement orphelins." #: library/multiprocessing.rst:614 msgid "" -"If this method is used when the associated process is using a pipe or queue " -"then the pipe or queue is liable to become corrupted and may become unusable " -"by other process. Similarly, if the process has acquired a lock or " -"semaphore etc. then terminating it is liable to cause other processes to " -"deadlock." +"If this method is used when the associated process is using a pipe or queue then the pipe or queue is liable to " +"become corrupted and may become unusable by other process. Similarly, if the process has acquired a lock or " +"semaphore etc. then terminating it is liable to cause other processes to deadlock." msgstr "" -"Si cette méthode est utilisée quand le processus associé utilise un tube ou " -"une queue, alors le tube ou la queue sont susceptibles d'être corrompus et " -"peuvent devenir inutilisables par les autres processus. De façon similaire, " -"si le processus a acquis un verrou, un sémaphore ou autre, alors le terminer " -"est susceptible de provoquer des blocages dans les autres processus." +"Si cette méthode est utilisée quand le processus associé utilise un tube ou une file, alors le tube ou la file" +"sont susceptibles d'être corrompus et peuvent devenir inutilisables par les autres processus. De façon similaire, " +"si le processus a acquis un verrou, un sémaphore ou autre, alors le terminer est susceptible de provoquer des " +"blocages dans les autres processus." #: library/multiprocessing.rst:622 msgid "Same as :meth:`terminate()` but using the ``SIGKILL`` signal on Unix." -msgstr "" -"Identique à :meth:`terminate()` mais utilisant le signal ``SIGKILL`` sous " -"Unix." +msgstr "Identique à :meth:`terminate()` mais utilisant le signal ``SIGKILL`` sous Unix." #: library/multiprocessing.rst:628 msgid "" -"Close the :class:`Process` object, releasing all resources associated with " -"it. :exc:`ValueError` is raised if the underlying process is still " -"running. Once :meth:`close` returns successfully, most other methods and " +"Close the :class:`Process` object, releasing all resources associated with it. :exc:`ValueError` is raised if " +"the underlying process is still running. Once :meth:`close` returns successfully, most other methods and " "attributes of the :class:`Process` object will raise :exc:`ValueError`." msgstr "" -"Ferme l'objet :class:`Process`, libérant toutes les ressources qui lui sont " -"associées. Une :exc:`ValueError` est levée si le processus sous-jacent " -"tourne toujours. Une fois que :meth:`close` se termine avec succès, la " -"plupart des autres méthodes et attributs des objets :class:`Process` " -"lèveront une :exc:`ValueError`." +"Ferme l'objet :class:`Process`, libérant toutes les ressources qui lui sont associées. Une :exc:`ValueError` est " +"levée si le processus sous-jacent tourne toujours. Une fois que :meth:`close` se termine avec succès, la plupart " +"des autres méthodes et attributs des objets :class:`Process` lèveront une :exc:`ValueError`." #: library/multiprocessing.rst:636 msgid "" -"Note that the :meth:`start`, :meth:`join`, :meth:`is_alive`, :meth:" -"`terminate` and :attr:`exitcode` methods should only be called by the " -"process that created the process object." +"Note that the :meth:`start`, :meth:`join`, :meth:`is_alive`, :meth:`terminate` and :attr:`exitcode` methods " +"should only be called by the process that created the process object." msgstr "" -"Notez que les méthodes :meth:`start`, :meth:`join`, :meth:`is_alive`, :meth:" -"`terminate` et :attr:`exitcode` ne devraient être appelées que par le " -"processus ayant créé l'objet *process*." +"Notez que les méthodes :meth:`start`, :meth:`join`, :meth:`is_alive`, :meth:`terminate` et :attr:`exitcode` ne " +"doivent être appelées que par le processus ayant créé l'objet *process*." #: library/multiprocessing.rst:640 msgid "Example usage of some of the methods of :class:`Process`:" @@ -872,19 +715,17 @@ msgstr "La classe de base de toutes les exceptions de :mod:`multiprocessing`." #: library/multiprocessing.rst:665 msgid "" -"Exception raised by :meth:`Connection.recv_bytes_into()` when the supplied " -"buffer object is too small for the message read." +"Exception raised by :meth:`Connection.recv_bytes_into()` when the supplied buffer object is too small for the " +"message read." msgstr "" -"Exception levée par :meth:`Connection.recv_bytes_into()` quand l'objet " -"tampon fourni est trop petit pour le message à lire." +"Exception levée par :meth:`Connection.recv_bytes_into()` quand l'objet tampon fourni est trop petit pour le " +"message à lire." #: library/multiprocessing.rst:668 -msgid "" -"If ``e`` is an instance of :exc:`BufferTooShort` then ``e.args[0]`` will " -"give the message as a byte string." +msgid "If ``e`` is an instance of :exc:`BufferTooShort` then ``e.args[0]`` will give the message as a byte string." msgstr "" -"Si ``e`` est une instance de :exc:`BufferTooShort` alors ``e.args[0]`` " -"donnera un message sous forme d'une chaîne d'octets." +"Si ``e`` est une instance de :exc:`BufferTooShort` alors ``e.args[0]`` donnera un message sous forme d'une chaîne " +"d'octets." #: library/multiprocessing.rst:673 msgid "Raised when there is an authentication error." @@ -892,281 +733,233 @@ msgstr "Levée quand il y a une erreur d'authentification." #: library/multiprocessing.rst:677 msgid "Raised by methods with a timeout when the timeout expires." -msgstr "" -"Levée par les méthodes avec temps d'exécution limité, quand ce temps expire." +msgstr "Levée par les méthodes avec temps d'exécution limité, quand ce temps expire." #: library/multiprocessing.rst:680 msgid "Pipes and Queues" -msgstr "Tubes (*pipes*) et Queues" +msgstr "Tubes (*pipes*) et files (*queues*)" #: library/multiprocessing.rst:682 msgid "" -"When using multiple processes, one generally uses message passing for " -"communication between processes and avoids having to use any synchronization " -"primitives like locks." +"When using multiple processes, one generally uses message passing for communication between processes and avoids " +"having to use any synchronization primitives like locks." msgstr "" -"Quand de multiples processus sont utilisés, de l'échange de messages est " -"souvent mis en place pour la communication entre processus et éviter d'avoir " -"à utiliser des primitives de synchronisation telles que des verrous." +"Quand de plusieurs processus travaillent ensemble, il est souvent nécessaire de les faire communiquer entre eux " +"pour éviter d'avoir à utiliser des primitives de synchronisation comme les verrous." #: library/multiprocessing.rst:686 msgid "" -"For passing messages one can use :func:`Pipe` (for a connection between two " -"processes) or a queue (which allows multiple producers and consumers)." +"For passing messages one can use :func:`Pipe` (for a connection between two processes) or a queue (which allows " +"multiple producers and consumers)." msgstr "" -"Pour échanger des messages vous pouvez utiliser un :func:`Pipe` (pour une " -"connexion entre deux processus) ou une queue (qui autorise de multiples " -"producteurs et consommateurs)." +"Pour échanger des messages vous pouvez utiliser un :func:`Pipe` (pour une connexion entre deux processus) ou une " +"file (qui autorise de plusieurs producteurs et consommateurs)." #: library/multiprocessing.rst:689 msgid "" -"The :class:`Queue`, :class:`SimpleQueue` and :class:`JoinableQueue` types " -"are multi-producer, multi-consumer :abbr:`FIFO (first-in, first-out)` queues " -"modelled on the :class:`queue.Queue` class in the standard library. They " -"differ in that :class:`Queue` lacks the :meth:`~queue.Queue.task_done` and :" -"meth:`~queue.Queue.join` methods introduced into Python 2.5's :class:`queue." -"Queue` class." +"The :class:`Queue`, :class:`SimpleQueue` and :class:`JoinableQueue` types are multi-producer, multi-consumer :" +"abbr:`FIFO (first-in, first-out)` queues modelled on the :class:`queue.Queue` class in the standard library. " +"They differ in that :class:`Queue` lacks the :meth:`~queue.Queue.task_done` and :meth:`~queue.Queue.join` methods " +"introduced into Python 2.5's :class:`queue.Queue` class." msgstr "" -"Les types :class:`Queue`, :class:`SimpleQueue` et :class:`JoinableQueue` " -"sont des queues :abbr:`FIFO (first-in, first-out)` multi-producteurs et " -"multi-consommateurs modelées sur la classe :class:`queue.Queue` de la " -"bibliothèque standard. Elles diffèrent par l'absence dans :class:`Queue` des " -"méthodes :meth:`~queue.Queue.task_done` et :meth:`~queue.Queue.join` " -"introduites dans la classe :class:`queue.Queue` par Python 2.5." +"Les types :class:`Queue`, :class:`SimpleQueue` et :class:`JoinableQueue` sont des files :abbr:`FIFO (first-in, " +"first-out)` multi-producteurs et multi-consommateurs modelées sur la classe :class:`queue.Queue` de la " +"bibliothèque standard. Elles diffèrent par l'absence dans :class:`Queue` des méthodes :meth:`~queue.Queue." +"task_done` et :meth:`~queue.Queue.join` introduites dans la classe :class:`queue.Queue` par Python 2.5." #: library/multiprocessing.rst:696 msgid "" -"If you use :class:`JoinableQueue` then you **must** call :meth:" -"`JoinableQueue.task_done` for each task removed from the queue or else the " -"semaphore used to count the number of unfinished tasks may eventually " -"overflow, raising an exception." +"If you use :class:`JoinableQueue` then you **must** call :meth:`JoinableQueue.task_done` for each task removed " +"from the queue or else the semaphore used to count the number of unfinished tasks may eventually overflow, " +"raising an exception." msgstr "" -"Si vous utilisez :class:`JoinableQueue` alors vous **devez** appeler :meth:" -"`JoinableQueue.task_done` pour chaque tâche retirée de la queue, sans quoi " -"le sémaphore utilisé pour compter le nombre de tâches non accomplies pourra " +"Si vous utilisez :class:`JoinableQueue` alors vous **devez** appeler :meth:`JoinableQueue.task_done` pour chaque " +"tâche retirée de la file, sans quoi le sémaphore utilisé pour compter le nombre de tâches non accomplies pourra " "éventuellement déborder, levant une exception." #: library/multiprocessing.rst:701 msgid "" -"Note that one can also create a shared queue by using a manager object -- " -"see :ref:`multiprocessing-managers`." +"Note that one can also create a shared queue by using a manager object -- see :ref:`multiprocessing-managers`." msgstr "" -"Notez que vous pouvez aussi créer une queue partagée en utilisant un objet " -"gestionnaire – voir :ref:`multiprocessing-managers`." +"Notez que vous pouvez aussi créer une file partagée en utilisant un objet gestionnaire – voir :ref:" +"`multiprocessing-managers`." #: library/multiprocessing.rst:706 msgid "" -":mod:`multiprocessing` uses the usual :exc:`queue.Empty` and :exc:`queue." -"Full` exceptions to signal a timeout. They are not available in the :mod:" -"`multiprocessing` namespace so you need to import them from :mod:`queue`." +":mod:`multiprocessing` uses the usual :exc:`queue.Empty` and :exc:`queue.Full` exceptions to signal a timeout. " +"They are not available in the :mod:`multiprocessing` namespace so you need to import them from :mod:`queue`." msgstr "" -":mod:`multiprocessing` utilise les exceptions habituelles :exc:`queue.Empty` " -"et :exc:`queue.Full` pour signaler un dépassement du temps maximal autorisé. " -"Elles ne sont pas disponibles dans l'espace de nommage :mod:" +":mod:`multiprocessing` utilise les exceptions habituelles :exc:`queue.Empty` et :exc:`queue.Full` pour signaler " +"un dépassement du temps maximal autorisé. Elles ne sont pas disponibles dans l'espace de nommage :mod:" "`multiprocessing` donc vous devez les importer depuis le module :mod:`queue`." #: library/multiprocessing.rst:713 msgid "" -"When an object is put on a queue, the object is pickled and a background " -"thread later flushes the pickled data to an underlying pipe. This has some " -"consequences which are a little surprising, but should not cause any " -"practical difficulties -- if they really bother you then you can instead use " -"a queue created with a :ref:`manager `." +"When an object is put on a queue, the object is pickled and a background thread later flushes the pickled data to " +"an underlying pipe. This has some consequences which are a little surprising, but should not cause any practical " +"difficulties -- if they really bother you then you can instead use a queue created with a :ref:`manager " +"`." msgstr "" -"Quand un objet est placé dans une queue, l'objet est sérialisé par *pickle* " -"et un fil d'exécution en arrière-plan transmettra ensuite les données " -"sérialisées sur un tube sous-jacent. Cela a certaines conséquences qui " -"peuvent être un peu surprenantes, mais ne devrait causer aucune difficultés " -"pratiques – si elles vous embêtent vraiment, alors vous pouvez à la place " -"utiliser une queue créée avec un :ref:`manager `." +"Quand un objet est placé dans une file, l'objet est sérialisé par *pickle* et un fil d'exécution en arrière-plan " +"transmettra ensuite les données sérialisées sur un tube sous-jacent. Cela a certaines conséquences qui peuvent " +"être un peu surprenantes, mais ne devrait causer aucune difficulté pratique — si elles vous embêtent vraiment, " +"alors vous pouvez à la place utiliser une file créée avec un :ref:`manager `." #: library/multiprocessing.rst:720 msgid "" -"After putting an object on an empty queue there may be an infinitesimal " -"delay before the queue's :meth:`~Queue.empty` method returns :const:`False` " -"and :meth:`~Queue.get_nowait` can return without raising :exc:`queue.Empty`." +"After putting an object on an empty queue there may be an infinitesimal delay before the queue's :meth:`~Queue." +"empty` method returns :const:`False` and :meth:`~Queue.get_nowait` can return without raising :exc:`queue.Empty`." msgstr "" -"Après avoir placé un objet dans une queue vide il peut y avoir un délai " -"infinitésimal avant que la méthode :meth:`~Queue.empty` de la queue renvoie :" -"const:`False` et que :meth:`~Queue.get_nowait` renvoie une valeur sans lever " +"Après avoir placé un objet dans une file vide il peut y avoir un délai infinitésimal avant que la méthode :meth:" +"`~Queue.empty` de la file renvoie :const:`False` et que :meth:`~Queue.get_nowait` renvoie une valeur sans lever " "de :exc:`queue.Empty`." #: library/multiprocessing.rst:725 msgid "" -"If multiple processes are enqueuing objects, it is possible for the objects " -"to be received at the other end out-of-order. However, objects enqueued by " -"the same process will always be in the expected order with respect to each " +"If multiple processes are enqueuing objects, it is possible for the objects to be received at the other end out-" +"of-order. However, objects enqueued by the same process will always be in the expected order with respect to each " "other." msgstr "" -"Si plusieurs processus placent des objets dans la queue, il est possible " -"pour les objets d'être reçus de l'autre côté dans le désordre. Cependant, " -"les objets placés par un même processus seront toujours récupérés dans " -"l'ordre attendu." +"Si plusieurs processus placent des objets dans la file, il est possible pour les objets d'être reçus de l'autre " +"côté dans le désordre. Cependant, les objets placés par un même processus seront toujours récupérés dans l'ordre " +"d'insertion." #: library/multiprocessing.rst:732 msgid "" -"If a process is killed using :meth:`Process.terminate` or :func:`os.kill` " -"while it is trying to use a :class:`Queue`, then the data in the queue is " -"likely to become corrupted. This may cause any other process to get an " +"If a process is killed using :meth:`Process.terminate` or :func:`os.kill` while it is trying to use a :class:" +"`Queue`, then the data in the queue is likely to become corrupted. This may cause any other process to get an " "exception when it tries to use the queue later on." msgstr "" -"Si un processus est tué à l'aide de :meth:`Process.terminate` ou :func:`os." -"kill` pendant qu'il tente d'utiliser une :class:`Queue`, alors les données " -"de la queue peuvent être corrompues. Cela peut par la suite causer des " -"levées d'exceptions dans les autres processus quand ils tenteront d'utiliser " -"la queue." +"Si un processus est tué à l'aide de :meth:`Process.terminate` ou :func:`os.kill` pendant qu'il tente d'utiliser " +"une :class:`Queue`, alors les données de la file peuvent être corrompues. Cela peut par la suite causer des " +"levées d'exceptions dans les autres processus quand ils tenteront d'utiliser la file." #: library/multiprocessing.rst:739 msgid "" -"As mentioned above, if a child process has put items on a queue (and it has " -"not used :meth:`JoinableQueue.cancel_join_thread `), then that process will not terminate until all " +"As mentioned above, if a child process has put items on a queue (and it has not used :meth:`JoinableQueue." +"cancel_join_thread `), then that process will not terminate until all " "buffered items have been flushed to the pipe." msgstr "" -"Comme mentionné plus haut, si un processus fils a placé des éléments dans la " -"queue (et qu'il n'a pas utilisé :meth:`JoinableQueue.cancel_join_thread " -"`), alors le processus ne se " -"terminera pas tant que les éléments placés dans le tampon n'auront pas été " -"transmis au tube." +"Comme mentionné plus haut, si un processus fils a placé des éléments dans la file (et qu'il n'a pas utilisé :meth:" +"`JoinableQueue.cancel_join_thread `), alors le processus ne se " +"terminera pas tant que les éléments placés dans le tampon n'auront pas été transmis au tube." #: library/multiprocessing.rst:744 msgid "" -"This means that if you try joining that process you may get a deadlock " -"unless you are sure that all items which have been put on the queue have " -"been consumed. Similarly, if the child process is non-daemonic then the " -"parent process may hang on exit when it tries to join all its non-daemonic " -"children." +"This means that if you try joining that process you may get a deadlock unless you are sure that all items which " +"have been put on the queue have been consumed. Similarly, if the child process is non-daemonic then the parent " +"process may hang on exit when it tries to join all its non-daemonic children." msgstr "" -"Cela signifie que si vous essayez d'attendre ce processus vous pouvez " -"obtenir un interblocage, à moins que vous ne soyez sûr que tous les éléments " -"placés dans la queue ont été consommés. De même, si le processus fils n'est " -"pas un *daemon* alors le processus parent pourrait bloquer à la fermeture " -"quand il tentera d'attendre tous ses enfants non *daemons*." +"Cela signifie que si vous essayez d'attendre ce processus vous pouvez obtenir un interblocage, à moins que vous " +"ne soyez sûr que tous les éléments placés dans la file ont été consommés. De même, si le processus fils n'est pas " +"un *daemon* alors le processus parent pourrait bloquer à la fermeture quand il tentera d'attendre tous ses " +"enfants non *daemons*." #: library/multiprocessing.rst:749 -msgid "" -"Note that a queue created using a manager does not have this issue. See :" -"ref:`multiprocessing-programming`." +msgid "Note that a queue created using a manager does not have this issue. See :ref:`multiprocessing-programming`." msgstr "" -"Notez que la queue créée à l'aide d'un gestionnaire n'a pas ce problème. " -"Voir :ref:`multiprocessing-programming`." +"Notez que la file créée à l'aide d'un gestionnaire n'a pas ce problème. Voir :ref:`multiprocessing-programming`." #: library/multiprocessing.rst:752 -msgid "" -"For an example of the usage of queues for interprocess communication see :" -"ref:`multiprocessing-examples`." +msgid "For an example of the usage of queues for interprocess communication see :ref:`multiprocessing-examples`." msgstr "" -"Pour un exemple d'utilisation de queues pour de la communication entre les " -"processus, voir :ref:`multiprocessing-examples`." +"Pour un exemple d'utilisation de files pour de la communication entre les processus, voir :ref:`multiprocessing-" +"examples`." #: library/multiprocessing.rst:758 msgid "" -"Returns a pair ``(conn1, conn2)`` of :class:`~multiprocessing.connection." -"Connection` objects representing the ends of a pipe." +"Returns a pair ``(conn1, conn2)`` of :class:`~multiprocessing.connection.Connection` objects representing the " +"ends of a pipe." msgstr "" -"Renvoie une paire ``(conn1, conn2)`` d'objets :class:`~multiprocessing." -"connection.Connection` représentant les bouts d'un tube." +"Renvoie une paire ``(conn1, conn2)`` d'objets :class:`~multiprocessing.connection.Connection` représentant les " +"bouts d'un tube." #: library/multiprocessing.rst:762 msgid "" -"If *duplex* is ``True`` (the default) then the pipe is bidirectional. If " -"*duplex* is ``False`` then the pipe is unidirectional: ``conn1`` can only be " -"used for receiving messages and ``conn2`` can only be used for sending " +"If *duplex* is ``True`` (the default) then the pipe is bidirectional. If *duplex* is ``False`` then the pipe is " +"unidirectional: ``conn1`` can only be used for receiving messages and ``conn2`` can only be used for sending " "messages." msgstr "" -"Si *duplex* vaut ``True`` (par défaut), alors le tube est bidirectionnel. Si " -"*duplex* vaut ``False`` il est unidirectionnel : ``conn1`` ne peut être " -"utilisé que pour recevoir des messages et ``conn2`` que pour en envoyer." +"Si *duplex* vaut ``True`` (par défaut), alors le tube est bidirectionnel. Si *duplex* vaut ``False`` il est " +"unidirectionnel : ``conn1`` ne peut être utilisé que pour recevoir des messages et ``conn2`` que pour en envoyer." #: library/multiprocessing.rst:770 msgid "" -"Returns a process shared queue implemented using a pipe and a few locks/" -"semaphores. When a process first puts an item on the queue a feeder thread " -"is started which transfers objects from a buffer into the pipe." +"Returns a process shared queue implemented using a pipe and a few locks/semaphores. When a process first puts an " +"item on the queue a feeder thread is started which transfers objects from a buffer into the pipe." msgstr "" -"Renvoie une queue partagée entre les processus utilisant un tube et quelques " -"verrous/sémaphores. Quand un processus place initialement un élément sur la " -"queue, un fil d'exécution *feeder* est démarré pour transférer les objets du " -"tampon vers le tube." +"Renvoie une file partagée entre les processus utilisant un tube et quelques verrous / sémaphores. Quand un " +"processus place initialement un élément sur la file, un fil d'exécution *feeder* est démarré pour transférer les " +"objets du tampon vers le tube." #: library/multiprocessing.rst:774 msgid "" -"The usual :exc:`queue.Empty` and :exc:`queue.Full` exceptions from the " -"standard library's :mod:`queue` module are raised to signal timeouts." +"The usual :exc:`queue.Empty` and :exc:`queue.Full` exceptions from the standard library's :mod:`queue` module are " +"raised to signal timeouts." msgstr "" -"Les exceptions habituelles :exc:`queue.Empty` et :exc:`queue.Full` du " -"module :mod:`queue` de la bibliothèque standard sont levées pour signaler " -"les *timeouts*." +"Les exceptions habituelles :exc:`queue.Empty` et :exc:`queue.Full` du module :mod:`queue` de la bibliothèque " +"standard sont levées pour signaler les *timeouts*." #: library/multiprocessing.rst:777 msgid "" -":class:`Queue` implements all the methods of :class:`queue.Queue` except " -"for :meth:`~queue.Queue.task_done` and :meth:`~queue.Queue.join`." +":class:`Queue` implements all the methods of :class:`queue.Queue` except for :meth:`~queue.Queue.task_done` and :" +"meth:`~queue.Queue.join`." msgstr "" -":class:`Queue` implémente toutes les méthodes de :class:`queue.Queue` à " -"l'exception de :meth:`~queue.Queue.task_done` et :meth:`~queue.Queue.join`." +":class:`Queue` implémente toutes les méthodes de :class:`queue.Queue` à l'exception de :meth:`~queue.Queue." +"task_done` et :meth:`~queue.Queue.join`." #: library/multiprocessing.rst:782 msgid "" -"Return the approximate size of the queue. Because of multithreading/" -"multiprocessing semantics, this number is not reliable." +"Return the approximate size of the queue. Because of multithreading/multiprocessing semantics, this number is " +"not reliable." msgstr "" -"Renvoie la taille approximative de la queue. Ce nombre n'est pas fiable en " -"raison des problématiques de *multithreading* et *multiprocessing*." +"Renvoie la taille approximative de la file. Ce nombre n'est pas fiable en raison des problématiques de " +"*multithreading* et *multiprocessing*." #: library/multiprocessing.rst:785 msgid "" -"Note that this may raise :exc:`NotImplementedError` on Unix platforms like " -"Mac OS X where ``sem_getvalue()`` is not implemented." +"Note that this may raise :exc:`NotImplementedError` on Unix platforms like Mac OS X where ``sem_getvalue()`` is " +"not implemented." msgstr "" -"Notez que cela peut lever une :exc:`NotImplementedError` sous les " -"plateformes Unix telles que Mac OS X où ``sem_getvalue()`` n'est pas " -"implémentée." +"Notez que cela peut lever une :exc:`NotImplementedError` sous les plateformes Unix telles que Mac OS X où " +"``sem_getvalue()`` n'est pas implémentée." #: library/multiprocessing.rst:790 msgid "" -"Return ``True`` if the queue is empty, ``False`` otherwise. Because of " -"multithreading/multiprocessing semantics, this is not reliable." +"Return ``True`` if the queue is empty, ``False`` otherwise. Because of multithreading/multiprocessing semantics, " +"this is not reliable." msgstr "" -"Renvoie ``True`` si la queue est vide, ``False`` sinon. Cette valeur n'est " -"pas fiable en raison des problématiques de *multithreading* et " -"*multiprocessing*." +"Renvoie ``True`` si la file est vide, ``False`` sinon. Cette valeur n'est pas fiable en raison des problématiques " +"de *multithreading* et *multiprocessing*." #: library/multiprocessing.rst:795 msgid "" -"Return ``True`` if the queue is full, ``False`` otherwise. Because of " -"multithreading/multiprocessing semantics, this is not reliable." +"Return ``True`` if the queue is full, ``False`` otherwise. Because of multithreading/multiprocessing semantics, " +"this is not reliable." msgstr "" -"Renvoie ``True`` si la queue est pleine, ``False`` sinon. Cette valeur n'est " -"pas fiable en raison des problématiques de *multithreading* et " -"*multiprocessing*." +"Renvoie ``True`` si la file est pleine, ``False`` sinon. Cette valeur n'est pas fiable en raison des " +"problématiques de *multithreading* et *multiprocessing*." #: library/multiprocessing.rst:800 msgid "" -"Put obj into the queue. If the optional argument *block* is ``True`` (the " -"default) and *timeout* is ``None`` (the default), block if necessary until a " -"free slot is available. If *timeout* is a positive number, it blocks at " -"most *timeout* seconds and raises the :exc:`queue.Full` exception if no free " -"slot was available within that time. Otherwise (*block* is ``False``), put " -"an item on the queue if a free slot is immediately available, else raise " -"the :exc:`queue.Full` exception (*timeout* is ignored in that case)." -msgstr "" -"Place *obj* dans la queue. Si l'argument optionnel *block* vaut ``True`` " -"(par défaut) est que *timeout* est ``None`` (par défaut), bloque jusqu'à ce " -"qu'un slot libre soit disponible. Si *timeout* est un nombre positif, la " -"méthode bloquera au maximum *timeout* secondes et lèvera une exception :exc:" -"`queue.Full` si aucun slot libre n'a été trouvé dans le temps imparti. " -"Autrement (*block* vaut ``False``), place un élément dans la queue si un " -"slot libre est immédiatement disponible, ou lève une exception :exc:`queue." -"Full` dans le cas contraire (*timeout* est ignoré dans ce cas)." +"Put obj into the queue. If the optional argument *block* is ``True`` (the default) and *timeout* is ``None`` " +"(the default), block if necessary until a free slot is available. If *timeout* is a positive number, it blocks " +"at most *timeout* seconds and raises the :exc:`queue.Full` exception if no free slot was available within that " +"time. Otherwise (*block* is ``False``), put an item on the queue if a free slot is immediately available, else " +"raise the :exc:`queue.Full` exception (*timeout* is ignored in that case)." +msgstr "" +"Place *obj* dans la file. Si l'argument optionnel *block* vaut ``True`` (par défaut) est que *timeout* est " +"``None`` (par défaut), bloque jusqu'à ce qu'une place libre soit disponible. Si *timeout* est un nombre positif, " +"la méthode bloquera au maximum *timeout* secondes et lève une exception :exc:`queue.Full` si aucune place libre " +"n'a été trouvée dans le temps imparti. Autrement (*block* vaut ``False``), place un élément dans la file si une " +"place libre est immédiatement disponible, ou lève une exception :exc:`queue.Full` dans le cas contraire " +"(*timeout* est ignoré dans ce cas)." #: library/multiprocessing.rst:809 -msgid "" -"If the queue is closed, :exc:`ValueError` is raised instead of :exc:" -"`AssertionError`." +msgid "If the queue is closed, :exc:`ValueError` is raised instead of :exc:`AssertionError`." msgstr "" -"Si la queue a été marquée comme fermée, une :exc:`ValueError` est levée. " -"Auparavant, une :exc:`AssertionError` était levée." +"si la file a été marquée comme fermée, une :exc:`ValueError` est levée. Auparavant, une :exc:`AssertionError` " +"était levée." #: library/multiprocessing.rst:815 msgid "Equivalent to ``put(obj, False)``." @@ -1174,31 +967,24 @@ msgstr "Équivalent à ``put(obj, False)``." #: library/multiprocessing.rst:819 msgid "" -"Remove and return an item from the queue. If optional args *block* is " -"``True`` (the default) and *timeout* is ``None`` (the default), block if " -"necessary until an item is available. If *timeout* is a positive number, it " -"blocks at most *timeout* seconds and raises the :exc:`queue.Empty` exception " -"if no item was available within that time. Otherwise (block is ``False``), " -"return an item if one is immediately available, else raise the :exc:`queue." +"Remove and return an item from the queue. If optional args *block* is ``True`` (the default) and *timeout* is " +"``None`` (the default), block if necessary until an item is available. If *timeout* is a positive number, it " +"blocks at most *timeout* seconds and raises the :exc:`queue.Empty` exception if no item was available within that " +"time. Otherwise (block is ``False``), return an item if one is immediately available, else raise the :exc:`queue." "Empty` exception (*timeout* is ignored in that case)." msgstr "" -"Retire et renvoie un élément de la queue. Si l'argument optionnel *block* " -"vaut ``True`` (par défaut) et que *timeout* est ``None`` (par défaut), " -"bloque jusqu'à ce qu'un élément soit disponible. Si *timeout* (le délai " -"maximal autorisé) est un nombre positif, la méthode bloquera au maximum " -"*timeout* secondes et lèvera une exception :exc:`queue.Empty` si aucun " -"élément n'est disponible dans le temps imparti. Autrement (*block* vaut " -"``False``), renvoie un élément s'il est immédiatement disponible, ou lève " -"une exception :exc:`queue.Empty` dans le cas contraire (*timeout* est ignoré " -"dans ce cas)." +"Retire et renvoie un élément de la file. Si l'argument optionnel *block* vaut ``True`` (par défaut) et que " +"*timeout* est ``None`` (par défaut), bloque jusqu'à ce qu'un élément soit disponible. Si *timeout* (le délai " +"maximal autorisé) est un nombre positif, la méthode bloque au maximum *timeout* secondes et lève une exception :" +"exc:`queue.Empty` si aucun élément n'est disponible dans le temps imparti. Autrement (*block* vaut ``False``), " +"renvoie un élément s'il est immédiatement disponible, ou lève une exception :exc:`queue.Empty` dans le cas " +"contraire (*timeout* est ignoré dans ce cas)." #: library/multiprocessing.rst:827 -msgid "" -"If the queue is closed, :exc:`ValueError` is raised instead of :exc:" -"`OSError`." +msgid "If the queue is closed, :exc:`ValueError` is raised instead of :exc:`OSError`." msgstr "" -"Si la queue a été marquée comme terminée, une :exc:`ValueError` est levée. " -"Auparavant, une :exc:`OSError`. était levée." +"si la file a été marquée comme terminée, une :exc:`ValueError` est levée. Auparavant, une :exc:`OSError`. était " +"levée." #: library/multiprocessing.rst:833 msgid "Equivalent to ``get(False)``." @@ -1206,178 +992,144 @@ msgstr "Équivalent à ``get(False)``." #: library/multiprocessing.rst:835 msgid "" -":class:`multiprocessing.Queue` has a few additional methods not found in :" -"class:`queue.Queue`. These methods are usually unnecessary for most code:" +":class:`multiprocessing.Queue` has a few additional methods not found in :class:`queue.Queue`. These methods are " +"usually unnecessary for most code:" msgstr "" -":class:`multiprocessing.Queue` possède quelques méthodes additionnelles non " -"présentes dans :class:`queue.Queue`. Ces méthodes ne sont habituellement pas " -"nécessaires pour la plupart des codes :" +":class:`multiprocessing.Queue` possède quelques méthodes additionnelles non présentes dans :class:`queue.Queue`. " +"Ces méthodes ne sont habituellement pas nécessaires pour la plupart des codes :" #: library/multiprocessing.rst:841 msgid "" -"Indicate that no more data will be put on this queue by the current " -"process. The background thread will quit once it has flushed all buffered " -"data to the pipe. This is called automatically when the queue is garbage " +"Indicate that no more data will be put on this queue by the current process. The background thread will quit " +"once it has flushed all buffered data to the pipe. This is called automatically when the queue is garbage " "collected." msgstr "" -"Indique que plus aucune donnée ne peut être placée sur la queue par le " -"processus courant. Le fil d'exécution en arrière-plan se terminera quand il " -"aura transféré toutes les données du tampon vers le tube. Elle est appelée " -"automatiquement quand la queue est collectée par le ramasse-miettes." +"Indique que plus aucune donnée ne peut être placée sur la file par le processus courant. Le fil d'exécution en " +"arrière-plan se terminera quand il aura transféré toutes les données du tampon vers le tube. Elle est appelée " +"automatiquement quand la file est collectée par le ramasse-miettes." #: library/multiprocessing.rst:848 msgid "" -"Join the background thread. This can only be used after :meth:`close` has " -"been called. It blocks until the background thread exits, ensuring that all " -"data in the buffer has been flushed to the pipe." +"Join the background thread. This can only be used after :meth:`close` has been called. It blocks until the " +"background thread exits, ensuring that all data in the buffer has been flushed to the pipe." msgstr "" -"Attend le fil d'exécution d'arrière-plan. Elle peut seulement être utilisée " -"une fois que :meth:`close` a été appelée. Elle bloque jusqu'à ce que le fil " -"d'arrière-plan se termine, assurant que toutes les données du tampon ont été " -"transmises au tube." +"Attend le fil d'exécution d'arrière-plan. Elle peut seulement être utilisée une fois que :meth:`close` a été " +"appelée. Elle bloque jusqu'à ce que le fil d'arrière-plan se termine, assurant que toutes les données du tampon " +"ont été transmises au tube." #: library/multiprocessing.rst:852 msgid "" -"By default if a process is not the creator of the queue then on exit it will " -"attempt to join the queue's background thread. The process can call :meth:" -"`cancel_join_thread` to make :meth:`join_thread` do nothing." +"By default if a process is not the creator of the queue then on exit it will attempt to join the queue's " +"background thread. The process can call :meth:`cancel_join_thread` to make :meth:`join_thread` do nothing." msgstr "" -"Par défaut si un processus n'est pas le créateur de la queue alors à la " -"fermeture elle essaiera d'attendre le fil d'exécution d'arrière-plan de la " -"queue. Le processus peut appeler :meth:`cancel_join_thread` pour que :meth:" +"Par défaut si un processus n'est pas le créateur de la file alors à la fermeture elle essaie d'attendre le fil " +"d'exécution d'arrière-plan de la file. Le processus peut appeler :meth:`cancel_join_thread` pour que :meth:" "`join_thread` ne fasse rien." #: library/multiprocessing.rst:858 msgid "" -"Prevent :meth:`join_thread` from blocking. In particular, this prevents the " -"background thread from being joined automatically when the process exits -- " -"see :meth:`join_thread`." +"Prevent :meth:`join_thread` from blocking. In particular, this prevents the background thread from being joined " +"automatically when the process exits -- see :meth:`join_thread`." msgstr "" -"Empêche :meth:`join_thread` de bloquer. En particulier, cela empêche le fil " -"d'arrière-plan d'être attendu automatiquement quand le processus se ferme – " -"voir :meth:`join_thread`." +"Empêche :meth:`join_thread` de bloquer. En particulier, cela empêche le fil d'arrière-plan d'être attendu " +"automatiquement quand le processus se ferme – voir :meth:`join_thread`." #: library/multiprocessing.rst:862 msgid "" -"A better name for this method might be ``allow_exit_without_flush()``. It " -"is likely to cause enqueued data to lost, and you almost certainly will not " -"need to use it. It is really only there if you need the current process to " -"exit immediately without waiting to flush enqueued data to the underlying " -"pipe, and you don't care about lost data." -msgstr "" -"Un meilleur nom pour cette méthode pourrait être " -"``allow_exit_without_flush()``. Cela peut provoquer des pertes de données " -"placées dans la queue, et vous ne devriez certainement pas avoir besoin de " -"l'utiliser. Elle n'est là que si vous souhaitez terminer immédiatement le " -"processus sans transférer les données du tampon, et que vous ne vous " +"A better name for this method might be ``allow_exit_without_flush()``. It is likely to cause enqueued data to " +"lost, and you almost certainly will not need to use it. It is really only there if you need the current process " +"to exit immediately without waiting to flush enqueued data to the underlying pipe, and you don't care about lost " +"data." +msgstr "" +"Un meilleur nom pour cette méthode pourrait être ``allow_exit_without_flush()``. Cela peut provoquer des pertes " +"de données placées dans la file, et il est très rare d'avoir besoin de l'utiliser. Elle n'est là que si vous " +"souhaitez terminer immédiatement le processus sans transférer les données du tampon, et que vous ne vous " "inquiétez pas de perdre des données." #: library/multiprocessing.rst:871 msgid "" -"This class's functionality requires a functioning shared semaphore " -"implementation on the host operating system. Without one, the functionality " -"in this class will be disabled, and attempts to instantiate a :class:`Queue` " -"will result in an :exc:`ImportError`. See :issue:`3770` for additional " -"information. The same holds true for any of the specialized queue types " -"listed below." +"This class's functionality requires a functioning shared semaphore implementation on the host operating system. " +"Without one, the functionality in this class will be disabled, and attempts to instantiate a :class:`Queue` will " +"result in an :exc:`ImportError`. See :issue:`3770` for additional information. The same holds true for any of " +"the specialized queue types listed below." msgstr "" -"Le fonctionnement de cette classe requiert une implémentation de sémaphore " -"partagé sur le système d'exploitation hôte. Sans cela, la fonctionnalité " -"sera désactivée et la tentative d'instancier une :class:`Queue` lèvera une :" -"exc:`ImportError`. Voir :issue:`3770` pour plus d'informations. Cette " -"remarque reste valable pour les autres types de queues spécialisées définies " -"par la suite." +"Le fonctionnement de cette classe requiert une implémentation de sémaphore partagé sur le système d'exploitation " +"hôte. Sans cela, la fonctionnalité est désactivée et la tentative d'instancier une :class:`Queue` lève une :exc:" +"`ImportError`. Voir :issue:`3770` pour plus d'informations. Cette remarque reste valable pour les autres types de " +"files spécialisées définies par la suite." #: library/multiprocessing.rst:880 -msgid "" -"It is a simplified :class:`Queue` type, very close to a locked :class:`Pipe`." -msgstr "" -"Un type de :class:`Queue` simplifié, très proche d'un :class:`Pipe` avec " -"verrou." +msgid "It is a simplified :class:`Queue` type, very close to a locked :class:`Pipe`." +msgstr "Un type de :class:`Queue` simplifié, très proche d'un :class:`Pipe` avec verrou." #: library/multiprocessing.rst:884 msgid "Close the queue: release internal resources." -msgstr "Ferme la queue : libère les ressources internes." +msgstr "Ferme la file : libère les ressources internes." #: library/multiprocessing.rst:886 msgid "" -"A queue must not be used anymore after it is closed. For example, :meth:" -"`get`, :meth:`put` and :meth:`empty` methods must no longer be called." +"A queue must not be used anymore after it is closed. For example, :meth:`get`, :meth:`put` and :meth:`empty` " +"methods must no longer be called." msgstr "" -"Une queue ne doit plus être utilisée après sa fermeture. Par exemple, les " -"méthodes :meth:`get`, :meth:`put` et :meth:`empty` ne doivent plus être " -"appelées." +"Une file ne doit plus être utilisée après sa fermeture. Par exemple, les méthodes :meth:`get`, :meth:`put` et :" +"meth:`empty` ne doivent plus être appelées." #: library/multiprocessing.rst:894 msgid "Return ``True`` if the queue is empty, ``False`` otherwise." -msgstr "Renvoie ``True`` si la queue est vide, ``False`` sinon." +msgstr "Renvoie ``True`` si la file est vide, ``False`` sinon." #: library/multiprocessing.rst:898 msgid "Remove and return an item from the queue." -msgstr "Supprime et renvoie un élément de la queue." +msgstr "Supprime et renvoie un élément de la file." #: library/multiprocessing.rst:902 msgid "Put *item* into the queue." -msgstr "Place *item* dans la queue." +msgstr "Place *item* dans la file." #: library/multiprocessing.rst:907 msgid "" -":class:`JoinableQueue`, a :class:`Queue` subclass, is a queue which " -"additionally has :meth:`task_done` and :meth:`join` methods." +":class:`JoinableQueue`, a :class:`Queue` subclass, is a queue which additionally has :meth:`task_done` and :meth:" +"`join` methods." msgstr "" -":class:`JoinableQueue`, une sous-classe de :class:`Queue`, est une queue qui " -"ajoute des méthodes :meth:`task_done` et :meth:`join`." +":class:`JoinableQueue`, une sous-classe de :class:`Queue`, est une file qui ajoute des méthodes :meth:`task_done` " +"et :meth:`join`." #: library/multiprocessing.rst:912 msgid "" -"Indicate that a formerly enqueued task is complete. Used by queue " -"consumers. For each :meth:`~Queue.get` used to fetch a task, a subsequent " -"call to :meth:`task_done` tells the queue that the processing on the task is " -"complete." +"Indicate that a formerly enqueued task is complete. Used by queue consumers. For each :meth:`~Queue.get` used to " +"fetch a task, a subsequent call to :meth:`task_done` tells the queue that the processing on the task is complete." msgstr "" -"Indique qu'une tâche précédemment placée dans la queue est complétée. " -"Utilisé par les consommateurs de la queue. Pour chaque :meth:`~Queue.get` " -"utilisé pour récupérer une tâche, un appel ultérieur à :meth:`task_done` " -"indique à la queue que le traitement de la tâche est terminé." +"Indique qu'une tâche précédemment placée dans la file est achevée. Utilisée par les consommateurs de la file. " +"Pour chaque :meth:`~Queue.get` utilisée pour récupérer une tâche, un appel ultérieur à :meth:`task_done` indique " +"à la file que le traitement de la tâche est terminé." #: library/multiprocessing.rst:917 msgid "" -"If a :meth:`~queue.Queue.join` is currently blocking, it will resume when " -"all items have been processed (meaning that a :meth:`task_done` call was " -"received for every item that had been :meth:`~Queue.put` into the queue)." +"If a :meth:`~queue.Queue.join` is currently blocking, it will resume when all items have been processed (meaning " +"that a :meth:`task_done` call was received for every item that had been :meth:`~Queue.put` into the queue)." msgstr "" -"Si un :meth:`~queue.Queue.join` est actuellement bloquant, il se débloquera " -"quand tous les éléments auront été traités (signifiant qu'un appel à :meth:" -"`task_done` a été reçu pour chaque élément ayant été placé via :meth:`~Queue." -"put` dans la queue)." +"Si un :meth:`~queue.Queue.join` est actuellement bloquant, il se débloquera quand tous les éléments auront été " +"traités (signifiant qu'un appel à :meth:`task_done` a été reçu pour chaque élément ayant été placé via :meth:" +"`~Queue.put` dans la file)." #: library/multiprocessing.rst:921 -msgid "" -"Raises a :exc:`ValueError` if called more times than there were items placed " -"in the queue." -msgstr "" -"Lève une exception :exc:`ValueError` si appelée plus de fois qu'il y avait " -"d'éléments dans la file." +msgid "Raises a :exc:`ValueError` if called more times than there were items placed in the queue." +msgstr "Lève une exception :exc:`ValueError` si appelée plus de fois qu'il y avait d'éléments dans la file." #: library/multiprocessing.rst:927 msgid "Block until all items in the queue have been gotten and processed." -msgstr "" -"Bloque jusqu'à ce que tous les éléments de la queue aient été récupérés et " -"traités." +msgstr "Bloque jusqu'à ce que tous les éléments de la file aient été récupérés et traités." #: library/multiprocessing.rst:929 msgid "" -"The count of unfinished tasks goes up whenever an item is added to the " -"queue. The count goes down whenever a consumer calls :meth:`task_done` to " -"indicate that the item was retrieved and all work on it is complete. When " -"the count of unfinished tasks drops to zero, :meth:`~queue.Queue.join` " -"unblocks." +"The count of unfinished tasks goes up whenever an item is added to the queue. The count goes down whenever a " +"consumer calls :meth:`task_done` to indicate that the item was retrieved and all work on it is complete. When " +"the count of unfinished tasks drops to zero, :meth:`~queue.Queue.join` unblocks." msgstr "" -"Le compteur des tâches non accomplies augmente chaque fois qu'un élément est " -"ajouté à la queue. Le compteur redescend chaque fois qu'un consommateur " -"appelle :meth:`task_done` pour indiquer qu'un élément a été récupéré et que " -"tout le travail qui le concerne est complété. Quand le compteur des tâches " -"non accomplies atteint zéro, :meth:`~queue.Queue.join` est débloquée." +"Le compteur des tâches non accomplies augmente chaque fois qu'un élément est ajouté à la file. Le compteur " +"redescend chaque fois qu'un consommateur appelle :meth:`task_done` pour indiquer qu'un élément a été récupéré et " +"que tout le travail qui le concerne est complété. Quand le compteur des tâches non accomplies atteint zéro, :meth:" +"`~queue.Queue.join` est débloquée." #: library/multiprocessing.rst:937 msgid "Miscellaneous" @@ -1388,12 +1140,8 @@ msgid "Return list of all live children of the current process." msgstr "Renvoie la liste de tous les enfants vivants du processus courant." #: library/multiprocessing.rst:943 -msgid "" -"Calling this has the side effect of \"joining\" any processes which have " -"already finished." -msgstr "" -"Appeler cette méthode provoque l'effet de bord d'attendre tout processus qui " -"n'a pas encore terminé." +msgid "Calling this has the side effect of \"joining\" any processes which have already finished." +msgstr "Appeler cette méthode provoque l'effet de bord d'attendre tout processus qui n'a pas encore terminé." #: library/multiprocessing.rst:948 msgid "Return the number of CPUs in the system." @@ -1401,13 +1149,11 @@ msgstr "Renvoie le nombre de CPU sur le système." #: library/multiprocessing.rst:950 msgid "" -"This number is not equivalent to the number of CPUs the current process can " -"use. The number of usable CPUs can be obtained with ``len(os." -"sched_getaffinity(0))``" +"This number is not equivalent to the number of CPUs the current process can use. The number of usable CPUs can " +"be obtained with ``len(os.sched_getaffinity(0))``" msgstr "" -"Ce nombre n'est pas équivalent au nombre de CPUs que le processus courant " -"peut utiliser. Le nombre de CPUs utilisables peut être obtenu avec ``len(os." -"sched_getaffinity(0))``" +"Ce nombre n'est pas équivalent au nombre de CPUs que le processus courant peut utiliser. Le nombre de CPUs " +"utilisables peut être obtenu avec ``len(os.sched_getaffinity(0))``" #: library/multiprocessing.rst:954 msgid "May raise :exc:`NotImplementedError`." @@ -1418,8 +1164,7 @@ msgid ":func:`os.cpu_count`" msgstr ":func:`os.cpu_count`" #: library/multiprocessing.rst:961 -msgid "" -"Return the :class:`Process` object corresponding to the current process." +msgid "Return the :class:`Process` object corresponding to the current process." msgstr "Renvoie l'objet :class:`Process` correspondant au processus courant." #: library/multiprocessing.rst:963 @@ -1428,121 +1173,96 @@ msgstr "Un analogue à :func:`threading.current_thread`." #: library/multiprocessing.rst:967 msgid "" -"Return the :class:`Process` object corresponding to the parent process of " -"the :func:`current_process`. For the main process, ``parent_process`` will " -"be ``None``." +"Return the :class:`Process` object corresponding to the parent process of the :func:`current_process`. For the " +"main process, ``parent_process`` will be ``None``." msgstr "" -"Renvoie l'objet :class:`Process` correspondant au processus père de :func:" -"`current_process`. Pour le processus maître, ``parent_process`` vaut " -"``None``." +"Renvoie l'objet :class:`Process` correspondant au processus père de :func:`current_process`. Pour le processus " +"maître, ``parent_process`` vaut ``None``." #: library/multiprocessing.rst:975 msgid "" -"Add support for when a program which uses :mod:`multiprocessing` has been " -"frozen to produce a Windows executable. (Has been tested with **py2exe**, " -"**PyInstaller** and **cx_Freeze**.)" +"Add support for when a program which uses :mod:`multiprocessing` has been frozen to produce a Windows " +"executable. (Has been tested with **py2exe**, **PyInstaller** and **cx_Freeze**.)" msgstr "" -"Ajoute le support des programmes utilisant :mod:`multiprocessing` qui ont " -"été figés pour produire un exécutable Windows. (Testé avec **py2exe**, " -"**PyInstaller** et **cx_Freeze**.)" +"Ajoute le support des programmes utilisant :mod:`multiprocessing` qui ont été figés pour produire un exécutable " +"Windows (testé avec **py2exe**, **PyInstaller** et **cx_Freeze**)." #: library/multiprocessing.rst:979 msgid "" -"One needs to call this function straight after the ``if __name__ == " -"'__main__'`` line of the main module. For example::" +"One needs to call this function straight after the ``if __name__ == '__main__'`` line of the main module. For " +"example::" msgstr "" -"Cette fonction doit être appelée juste après la ligne ``if __name__ == " -"'__main__'`` du module principal. Par exemple ::" +"Cette fonction doit être appelée juste après la ligne ``if __name__ == '__main__'`` du module principal. Par " +"exemple ::" #: library/multiprocessing.rst:991 msgid "" -"If the ``freeze_support()`` line is omitted then trying to run the frozen " -"executable will raise :exc:`RuntimeError`." +"If the ``freeze_support()`` line is omitted then trying to run the frozen executable will raise :exc:" +"`RuntimeError`." msgstr "" -"Si la ligne ``freeze_support()`` est omise, alors tenter de lancer " -"l'exécutable figé lèvera une :exc:`RuntimeError`." +"Si la ligne ``freeze_support()`` est omise, alors tenter de lancer l'exécutable figé lève une :exc:`RuntimeError`." #: library/multiprocessing.rst:994 msgid "" -"Calling ``freeze_support()`` has no effect when invoked on any operating " -"system other than Windows. In addition, if the module is being run normally " -"by the Python interpreter on Windows (the program has not been frozen), then " +"Calling ``freeze_support()`` has no effect when invoked on any operating system other than Windows. In addition, " +"if the module is being run normally by the Python interpreter on Windows (the program has not been frozen), then " "``freeze_support()`` has no effect." msgstr "" -"Appeler ``freeze_support()`` n'a pas d'effet quand elle est invoquée sur un " -"système d'exploitation autre que Windows. De plus, si le module est lancé " -"normalement par l'interpréteur Python sous Windows (le programme n'a pas été " -"figé), alors ``freeze_support()`` n'a pas d'effet." +"Appeler ``freeze_support()`` n'a pas d'effet quand elle est invoquée sur un système d'exploitation autre que " +"Windows. De plus, si le module est lancé normalement par l'interpréteur Python sous Windows (le programme n'a pas " +"été figé), alors ``freeze_support()`` n'a pas d'effet." #: library/multiprocessing.rst:1001 msgid "" -"Returns a list of the supported start methods, the first of which is the " -"default. The possible start methods are ``'fork'``, ``'spawn'`` and " -"``'forkserver'``. On Windows only ``'spawn'`` is available. On Unix " -"``'fork'`` and ``'spawn'`` are always supported, with ``'fork'`` being the " -"default." +"Returns a list of the supported start methods, the first of which is the default. The possible start methods are " +"``'fork'``, ``'spawn'`` and ``'forkserver'``. On Windows only ``'spawn'`` is available. On Unix ``'fork'`` and " +"``'spawn'`` are always supported, with ``'fork'`` being the default." msgstr "" -"Renvoie la liste des méthodes de démarrage supportées, la première étant " -"celle par défaut. Les méthodes de démarrage possibles sont ``'fork'``, " -"``'spawn'`` et ``'forkserver'``. Sous Windows seule ``'spawn'`` est " -"disponible. Sous Unix ``'fork'`` et ``'spawn'`` sont disponibles, ``'fork'`` " -"étant celle par défaut." +"Renvoie la liste des méthodes de démarrage supportées, la première étant celle par défaut. Les méthodes de " +"démarrage possibles sont ``'fork'``, ``'spawn'`` et ``'forkserver'``. Sous Windows seule ``'spawn'`` est " +"disponible. Sous Unix ``'fork'`` et ``'spawn'`` sont disponibles, ``'fork'`` étant celle par défaut." #: library/multiprocessing.rst:1011 -msgid "" -"Return a context object which has the same attributes as the :mod:" -"`multiprocessing` module." -msgstr "" -"Renvoie un contexte ayant les mêmes attributs que le module :mod:" -"`multiprocessing`." +msgid "Return a context object which has the same attributes as the :mod:`multiprocessing` module." +msgstr "Renvoie un contexte ayant les mêmes attributs que le module :mod:`multiprocessing`." #: library/multiprocessing.rst:1014 msgid "" -"If *method* is ``None`` then the default context is returned. Otherwise " -"*method* should be ``'fork'``, ``'spawn'``, ``'forkserver'``. :exc:" -"`ValueError` is raised if the specified start method is not available." +"If *method* is ``None`` then the default context is returned. Otherwise *method* should be ``'fork'``, " +"``'spawn'``, ``'forkserver'``. :exc:`ValueError` is raised if the specified start method is not available." msgstr "" -"Si *method* est ``None`` le contexte par défaut est renvoyé. Sinon *method* " -"doit valoir ``'fork'``, ``'spawn'`` ou ``'forkserver'``. Une :exc:" -"`ValueError` est levée si la méthode de démarrage spécifiée n'est pas " -"disponible." +"Si *method* est ``None`` le contexte par défaut est renvoyé. Sinon *method* doit valoir ``'fork'``, ``'spawn'`` " +"ou ``'forkserver'``. Une :exc:`ValueError` est levée si la méthode de démarrage spécifiée n'est pas disponible." #: library/multiprocessing.rst:1023 msgid "Return the name of start method used for starting processes." -msgstr "" -"Renvoie le nom de la méthode de démarrage utilisée pour démarrer le " -"processus." +msgstr "Renvoie le nom de la méthode de démarrage utilisée pour démarrer le processus." #: library/multiprocessing.rst:1025 msgid "" -"If the start method has not been fixed and *allow_none* is false, then the " -"start method is fixed to the default and the name is returned. If the start " -"method has not been fixed and *allow_none* is true then ``None`` is returned." +"If the start method has not been fixed and *allow_none* is false, then the start method is fixed to the default " +"and the name is returned. If the start method has not been fixed and *allow_none* is true then ``None`` is " +"returned." msgstr "" -"Si le nom de la méthode n'a pas été fixé et que *allow_none* est faux, alors " -"la méthode de démarrage est réglée à celle par défaut et son nom est " -"renvoyé. Si la méthode n'a pas été fixée et que *allow_none* est vrai, " -"``None`` est renvoyé." +"Si le nom de la méthode n'a pas été fixé et que *allow_none* est faux, alors la méthode de démarrage est réglée à " +"celle par défaut et son nom est renvoyé. Si la méthode n'a pas été fixée et que *allow_none* est vrai, ``None`` " +"est renvoyé." #: library/multiprocessing.rst:1030 msgid "" -"The return value can be ``'fork'``, ``'spawn'``, ``'forkserver'`` or " -"``None``. ``'fork'`` is the default on Unix, while ``'spawn'`` is the " -"default on Windows." +"The return value can be ``'fork'``, ``'spawn'``, ``'forkserver'`` or ``None``. ``'fork'`` is the default on " +"Unix, while ``'spawn'`` is the default on Windows." msgstr "" -"La valeur de retour peut être ``'fork'``, ``'spawn'``, ``'forkserver'`` ou " -"``None``. ``'fork'`` est la valeur par défaut sous Unix, ``'spawn'`` est " -"celle sous Windows." +"La valeur de retour peut être ``'fork'``, ``'spawn'``, ``'forkserver'`` ou ``None``. ``'fork'`` est la valeur par " +"défaut sous Unix, ``'spawn'`` est celle sous Windows." #: library/multiprocessing.rst:1038 msgid "" -"Sets the path of the Python interpreter to use when starting a child " -"process. (By default :data:`sys.executable` is used). Embedders will " -"probably need to do some thing like ::" +"Sets the path of the Python interpreter to use when starting a child process. (By default :data:`sys.executable` " +"is used). Embedders will probably need to do some thing like ::" msgstr "" -"Définit le chemin de l'interpréteur Python à utiliser pour démarrer un " -"processus fils. (Par défaut :data:`sys.executable` est utilisé). Les " -"intégrateurs devront probablement faire quelque chose comme ::" +"Définit le chemin de l'interpréteur Python à utiliser pour démarrer un processus fils. (Par défaut :data:`sys." +"executable` est utilisé). Les intégrateurs devront probablement faire quelque chose comme ::" #: library/multiprocessing.rst:1044 msgid "before they can create child processes." @@ -1550,38 +1270,32 @@ msgstr "avant de pouvoir créer des processus fils." #: library/multiprocessing.rst:1046 msgid "Now supported on Unix when the ``'spawn'`` start method is used." -msgstr "" -"Maintenant supporté sous Unix quand la méthode de démarrage ``'spawn'`` est " -"utilisée." +msgstr "Maintenant supporté sous Unix quand la méthode de démarrage ``'spawn'`` est utilisée." #: library/multiprocessing.rst:1051 msgid "" -"Set the method which should be used to start child processes. *method* can " -"be ``'fork'``, ``'spawn'`` or ``'forkserver'``." +"Set the method which should be used to start child processes. *method* can be ``'fork'``, ``'spawn'`` or " +"``'forkserver'``." msgstr "" -"Règle la méthode qui doit être utilisée pour démarrer un processus fils. " -"*method* peut être ``'fork'``, ``'spawn'`` ou ``'forkserver'``." +"Règle la méthode qui doit être utilisée pour démarrer un processus fils. *method* peut être ``'fork'``, " +"``'spawn'`` ou ``'forkserver'``." #: library/multiprocessing.rst:1054 msgid "" -"Note that this should be called at most once, and it should be protected " -"inside the ``if __name__ == '__main__'`` clause of the main module." +"Note that this should be called at most once, and it should be protected inside the ``if __name__ == '__main__'`` " +"clause of the main module." msgstr "" -"Notez que cette fonction ne devrait être appelée qu'une fois au plus, et " -"l'appel devrait être protégé à l'intérieur d'une clause ``if __name__ == " -"'__main__'`` dans le module principal." +"Notez que cette fonction ne devrait être appelée qu'une fois au plus, et l'appel devrait être protégé à " +"l'intérieur d'une clause ``if __name__ == '__main__'`` dans le module principal." #: library/multiprocessing.rst:1062 msgid "" -":mod:`multiprocessing` contains no analogues of :func:`threading." -"active_count`, :func:`threading.enumerate`, :func:`threading.settrace`, :" -"func:`threading.setprofile`, :class:`threading.Timer`, or :class:`threading." -"local`." +":mod:`multiprocessing` contains no analogues of :func:`threading.active_count`, :func:`threading.enumerate`, :" +"func:`threading.settrace`, :func:`threading.setprofile`, :class:`threading.Timer`, or :class:`threading.local`." msgstr "" -":mod:`multiprocessing` ne contient pas d'analogues à :func:`threading." -"active_count`, :func:`threading.enumerate`, :func:`threading.settrace`, :" -"func:`threading.setprofile`, :class:`threading.Timer`, ou :class:`threading." -"local`." +":mod:`multiprocessing` ne contient pas d'analogues à :func:`threading.active_count`, :func:`threading." +"enumerate`, :func:`threading.settrace`, :func:`threading.setprofile`, :class:`threading.Timer`, ou :class:" +"`threading.local`." #: library/multiprocessing.rst:1069 msgid "Connection Objects" @@ -1589,53 +1303,43 @@ msgstr "Objets de connexions" #: library/multiprocessing.rst:1073 msgid "" -"Connection objects allow the sending and receiving of picklable objects or " -"strings. They can be thought of as message oriented connected sockets." +"Connection objects allow the sending and receiving of picklable objects or strings. They can be thought of as " +"message oriented connected sockets." msgstr "" -"Les objets de connexion autorisent l'envoi et la réception d'objets " -"sérialisables ou de chaînes de caractères. Ils peuvent être vus comme des " -"interfaces de connexion (*sockets*) connectées orientées messages." +"Les objets de connexion autorisent l'envoi et la réception d'objets sérialisables ou de chaînes de caractères. " +"Ils peuvent être vus comme des interfaces de connexion (*sockets*) connectées orientées messages." #: library/multiprocessing.rst:1076 msgid "" -"Connection objects are usually created using :func:`Pipe ` -- see also :ref:`multiprocessing-listeners-clients`." +"Connection objects are usually created using :func:`Pipe ` -- see also :ref:" +"`multiprocessing-listeners-clients`." msgstr "" -"Les objets de connexion sont habituellement créés via :func:`Pipe " -"` – voir aussi :ref:`multiprocessing-listeners-" -"clients`." +"Les objets de connexion sont habituellement créés via :func:`Pipe ` – voir aussi :ref:" +"`multiprocessing-listeners-clients`." #: library/multiprocessing.rst:1084 -msgid "" -"Send an object to the other end of the connection which should be read " -"using :meth:`recv`." -msgstr "" -"Envoie un objet sur l'autre bout de la connexion, qui devra être lu avec :" -"meth:`recv`." +msgid "Send an object to the other end of the connection which should be read using :meth:`recv`." +msgstr "Envoie un objet sur l'autre bout de la connexion, qui devra être lu avec :meth:`recv`." #: library/multiprocessing.rst:1087 msgid "" -"The object must be picklable. Very large pickles (approximately 32 MiB+, " -"though it depends on the OS) may raise a :exc:`ValueError` exception." +"The object must be picklable. Very large pickles (approximately 32 MiB+, though it depends on the OS) may raise " +"a :exc:`ValueError` exception." msgstr "" -"L'objet doit être sérialisable. Les *pickles* très larges (approximativement " -"32 Mo+, bien que cela dépende de l'OS) pourront lever une exception :exc:" -"`ValueError`." +"L'objet doit être sérialisable. Les *pickles* très larges (approximativement 32 Mo+, bien que cela dépende de " +"l'OS) pourront lever une exception :exc:`ValueError`." #: library/multiprocessing.rst:1092 msgid "" -"Return an object sent from the other end of the connection using :meth:" -"`send`. Blocks until there is something to receive. Raises :exc:`EOFError` " -"if there is nothing left to receive and the other end was closed." +"Return an object sent from the other end of the connection using :meth:`send`. Blocks until there is something " +"to receive. Raises :exc:`EOFError` if there is nothing left to receive and the other end was closed." msgstr "" -"Renvoie un objet envoyé depuis l'autre bout de la connexion en utilisant :" -"meth:`send`. Bloque jusqu'à ce que quelque chose soit reçu. Lève une :exc:" -"`EOFError` s'il n'y a plus rien à recevoir et que l'autre bout a été fermé." +"Renvoie un objet envoyé depuis l'autre bout de la connexion en utilisant :meth:`send`. Bloque jusqu'à ce que " +"quelque chose soit reçu. Lève une :exc:`EOFError` s'il n'y a plus rien à recevoir et que l'autre bout a été fermé." #: library/multiprocessing.rst:1099 msgid "Return the file descriptor or handle used by the connection." -msgstr "" -"Renvoie le descripteur de fichier ou identifiant utilisé par la connexion." +msgstr "Renvoie le descripteur de fichier ou identifiant utilisé par la connexion." #: library/multiprocessing.rst:1103 msgid "Close the connection." @@ -1643,133 +1347,107 @@ msgstr "Ferme la connexion." #: library/multiprocessing.rst:1105 msgid "This is called automatically when the connection is garbage collected." -msgstr "" -"Elle est appelée automatiquement quand la connexion est collectée par le " -"ramasse-miettes." +msgstr "Elle est appelée automatiquement quand la connexion est collectée par le ramasse-miettes." #: library/multiprocessing.rst:1109 msgid "Return whether there is any data available to be read." -msgstr "" -"Renvoie vrai ou faux selon si des données sont disponibles à la lecture." +msgstr "Renvoie vrai ou faux selon si des données sont disponibles à la lecture." #: library/multiprocessing.rst:1111 msgid "" -"If *timeout* is not specified then it will return immediately. If *timeout* " -"is a number then this specifies the maximum time in seconds to block. If " -"*timeout* is ``None`` then an infinite timeout is used." +"If *timeout* is not specified then it will return immediately. If *timeout* is a number then this specifies the " +"maximum time in seconds to block. If *timeout* is ``None`` then an infinite timeout is used." msgstr "" -"Si *timeout* n'est pas spécifié la méthode renverra immédiatement. Si " -"*timeout* est un nombre alors il spécifie le temps maximum de blocage en " -"secondes. Si *timeout* est ``None``, un temps d'attente infini est utilisé." +"Si *timeout* n'est pas spécifié la méthode renverra immédiatement. Si *timeout* est un nombre alors il spécifie " +"le temps maximum de blocage en secondes. Si *timeout* est ``None``, un temps d'attente infini est utilisé." #: library/multiprocessing.rst:1115 msgid "" -"Note that multiple connection objects may be polled at once by using :func:" -"`multiprocessing.connection.wait`." +"Note that multiple connection objects may be polled at once by using :func:`multiprocessing.connection.wait`." msgstr "" -"Notez que plusieurs objets de connexions peuvent être attendus en même temps " -"à l'aide de :func:`multiprocessing.connection.wait`." +"Notez que plusieurs objets de connexions peuvent être attendus en même temps à l'aide de :func:`multiprocessing." +"connection.wait`." #: library/multiprocessing.rst:1120 msgid "Send byte data from a :term:`bytes-like object` as a complete message." -msgstr "" -"Envoie des données binaires depuis un :term:`bytes-like object` comme un " -"message complet." +msgstr "Envoie des données binaires depuis un :term:`bytes-like object` comme un message complet." #: library/multiprocessing.rst:1122 msgid "" -"If *offset* is given then data is read from that position in *buffer*. If " -"*size* is given then that many bytes will be read from buffer. Very large " -"buffers (approximately 32 MiB+, though it depends on the OS) may raise a :" +"If *offset* is given then data is read from that position in *buffer*. If *size* is given then that many bytes " +"will be read from buffer. Very large buffers (approximately 32 MiB+, though it depends on the OS) may raise a :" "exc:`ValueError` exception" msgstr "" -"Si *offset* est fourni, les données sont lues depuis cette position dans le " -"tampon *buffer*. Si *size* est fourni, il indique le nombre d'octets qui " -"seront lus depuis *buffer*. Les tampons très larges (approximativement 32 MiB" -"+, bien que cela dépende de l'OS) pourront lever une exception :exc:" -"`ValueError`." +"Si *offset* est fourni, les données sont lues depuis cette position dans le tampon *buffer*. Si *size* est " +"fourni, il indique le nombre d'octets qui seront lus depuis *buffer*. Les tampons très larges (approximativement " +"32 MiB+, bien que cela dépende de l'OS) pourront lever une exception :exc:`ValueError`." #: library/multiprocessing.rst:1129 msgid "" -"Return a complete message of byte data sent from the other end of the " -"connection as a string. Blocks until there is something to receive. Raises :" -"exc:`EOFError` if there is nothing left to receive and the other end has " -"closed." +"Return a complete message of byte data sent from the other end of the connection as a string. Blocks until there " +"is something to receive. Raises :exc:`EOFError` if there is nothing left to receive and the other end has closed." msgstr "" -"Renvoie un message complet de données binaires envoyées depuis l'autre bout " -"de la connexion comme une chaîne de caractères. Bloque jusqu'à ce qu'il y " -"ait quelque chose à recevoir. Lève une :exc:`EOFError` s'il ne reste rien à " +"Renvoie un message complet de données binaires envoyées depuis l'autre bout de la connexion comme une chaîne de " +"caractères. Bloque jusqu'à ce qu'il y ait quelque chose à recevoir. Lève une :exc:`EOFError` s'il ne reste rien à " "recevoir et que l'autre côté de la connexion a été fermé." #: library/multiprocessing.rst:1134 msgid "" -"If *maxlength* is specified and the message is longer than *maxlength* then :" -"exc:`OSError` is raised and the connection will no longer be readable." +"If *maxlength* is specified and the message is longer than *maxlength* then :exc:`OSError` is raised and the " +"connection will no longer be readable." msgstr "" -"Si *maxlength* est précisé que que le message est plus long que *maxlength* " -"alors une :exc:`OSError` est levée et la connexion n'est plus lisible." +"Si *maxlength* est précisé que que le message est plus long que *maxlength* alors une :exc:`OSError` est levée et " +"la connexion n'est plus lisible." #: library/multiprocessing.rst:1138 -msgid "" -"This function used to raise :exc:`IOError`, which is now an alias of :exc:" -"`OSError`." -msgstr "" -"Cette fonction levait auparavant une :exc:`IOError`, qui est maintenant un " -"alias pour :exc:`OSError`." +msgid "This function used to raise :exc:`IOError`, which is now an alias of :exc:`OSError`." +msgstr "Cette fonction levait auparavant une :exc:`IOError`, qui est maintenant un alias pour :exc:`OSError`." #: library/multiprocessing.rst:1145 msgid "" -"Read into *buffer* a complete message of byte data sent from the other end " -"of the connection and return the number of bytes in the message. Blocks " -"until there is something to receive. Raises :exc:`EOFError` if there is " +"Read into *buffer* a complete message of byte data sent from the other end of the connection and return the " +"number of bytes in the message. Blocks until there is something to receive. Raises :exc:`EOFError` if there is " "nothing left to receive and the other end was closed." msgstr "" -"Lit et stocke dans *buffer* un message complet de données binaires envoyées " -"depuis l'autre bout de la connexion et renvoie le nombre d'octets du " -"message. Bloque jusqu'à ce qu'il y ait quelque chose à recevoir. Lève une :" -"exc:`EOFError` s'il ne reste rien à recevoir et que l'autre côté de la " -"connexion a été fermé." +"Lit et stocke dans *buffer* un message complet de données binaires envoyées depuis l'autre bout de la connexion " +"et renvoie le nombre d'octets du message. Bloque jusqu'à ce qu'il y ait quelque chose à recevoir. Lève une :exc:" +"`EOFError` s'il ne reste rien à recevoir et que l'autre côté de la connexion a été fermé." #: library/multiprocessing.rst:1151 msgid "" -"*buffer* must be a writable :term:`bytes-like object`. If *offset* is given " -"then the message will be written into the buffer from that position. Offset " -"must be a non-negative integer less than the length of *buffer* (in bytes)." +"*buffer* must be a writable :term:`bytes-like object`. If *offset* is given then the message will be written " +"into the buffer from that position. Offset must be a non-negative integer less than the length of *buffer* (in " +"bytes)." msgstr "" -"*buffer* doit être un :term:`bytes-like object` accessible en écriture. Si " -"*offset* est donné, le message sera écrit dans le tampon à partir de cette " -"position. *offset* doit être un entier positif, inférieur à la taille de " +"*buffer* doit être un :term:`bytes-like object` accessible en écriture. Si *offset* est donné, le message sera " +"écrit dans le tampon à partir de cette position. *offset* doit être un entier positif, inférieur à la taille de " "*buffer* (en octets)." #: library/multiprocessing.rst:1156 msgid "" -"If the buffer is too short then a :exc:`BufferTooShort` exception is raised " -"and the complete message is available as ``e.args[0]`` where ``e`` is the " -"exception instance." +"If the buffer is too short then a :exc:`BufferTooShort` exception is raised and the complete message is available " +"as ``e.args[0]`` where ``e`` is the exception instance." msgstr "" -"Si le tampon est trop petit une exception :exc:`BufferTooShort` est levée et " -"le message complet est accessible via ``e.args[0]`` où ``e`` est l'instance " -"de l'exception." +"Si le tampon est trop petit une exception :exc:`BufferTooShort` est levée et le message complet est accessible " +"via ``e.args[0]`` où ``e`` est l'instance de l'exception." #: library/multiprocessing.rst:1160 msgid "" -"Connection objects themselves can now be transferred between processes " -"using :meth:`Connection.send` and :meth:`Connection.recv`." +"Connection objects themselves can now be transferred between processes using :meth:`Connection.send` and :meth:" +"`Connection.recv`." msgstr "" -"Les objets de connexions eux-mêmes peuvent maintenant être transférés entre " -"les processus en utilisant :meth:`Connection.send` et :meth:`Connection." -"recv`." +"Les objets de connexions eux-mêmes peuvent maintenant être transférés entre les processus en utilisant :meth:" +"`Connection.send` et :meth:`Connection.recv`." #: library/multiprocessing.rst:1164 msgid "" -"Connection objects now support the context management protocol -- see :ref:" -"`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the " -"connection object, and :meth:`~contextmanager.__exit__` calls :meth:`close`." +"Connection objects now support the context management protocol -- see :ref:`typecontextmanager`. :meth:" +"`~contextmanager.__enter__` returns the connection object, and :meth:`~contextmanager.__exit__` calls :meth:" +"`close`." msgstr "" -"Les objets de connexions supportent maintenant le protocole des " -"gestionnaires de contexte – voir :ref:`typecontextmanager`. :meth:" -"`~contextmanager.__enter__` renvoie l'objet de connexion, et :meth:" -"`~contextmanager.__exit__` appelle :meth:`close`." +"Les objets de connexions supportent maintenant le protocole des gestionnaires de contexte – voir :ref:" +"`typecontextmanager`. :meth:`~contextmanager.__enter__` renvoie l'objet de connexion, et :meth:`~contextmanager." +"__exit__` appelle :meth:`close`." #: library/multiprocessing.rst:1169 msgid "For example:" @@ -1777,35 +1455,29 @@ msgstr "Par exemple :" #: library/multiprocessing.rst:1193 msgid "" -"The :meth:`Connection.recv` method automatically unpickles the data it " -"receives, which can be a security risk unless you can trust the process " -"which sent the message." +"The :meth:`Connection.recv` method automatically unpickles the data it receives, which can be a security risk " +"unless you can trust the process which sent the message." msgstr "" -"La méthode :meth:`Connection.recv` désérialise automatiquement les données " -"qu'elle reçoit, ce qui peut être un risque de sécurité à moins que vous ne " -"fassiez réellement confiance au processus émetteur du message." +"La méthode :meth:`Connection.recv` désérialise automatiquement les données qu'elle reçoit, ce qui peut être un " +"risque de sécurité à moins que vous ne fassiez réellement confiance au processus émetteur du message." #: library/multiprocessing.rst:1197 msgid "" -"Therefore, unless the connection object was produced using :func:`Pipe` you " -"should only use the :meth:`~Connection.recv` and :meth:`~Connection.send` " -"methods after performing some sort of authentication. See :ref:" +"Therefore, unless the connection object was produced using :func:`Pipe` you should only use the :meth:" +"`~Connection.recv` and :meth:`~Connection.send` methods after performing some sort of authentication. See :ref:" "`multiprocessing-auth-keys`." msgstr "" -"Par conséquent, à moins que l'objet de connexion soit instancié par :func:" -"`Pipe`, vous ne devriez uniquement utiliser les méthodes :meth:`~Connection." -"recv` et :meth:`~Connection.send` après avoir effectué une quelconque forme " -"d'authentification. Voir :ref:`multiprocessing-auth-keys`." +"Par conséquent, à moins que l'objet de connexion soit instancié par :func:`Pipe`, vous ne devriez uniquement " +"utiliser les méthodes :meth:`~Connection.recv` et :meth:`~Connection.send` après avoir effectué une quelconque " +"forme d'authentification. Voir :ref:`multiprocessing-auth-keys`." #: library/multiprocessing.rst:1204 msgid "" -"If a process is killed while it is trying to read or write to a pipe then " -"the data in the pipe is likely to become corrupted, because it may become " -"impossible to be sure where the message boundaries lie." +"If a process is killed while it is trying to read or write to a pipe then the data in the pipe is likely to " +"become corrupted, because it may become impossible to be sure where the message boundaries lie." msgstr "" -"Si un processus est tué pendant qu'il essaye de lire ou écrire sur le tube, " -"alors les données du tube ont des chances d'être corrompues, parce qu'il " -"devient impossible d'être sûr d'où se trouvent les bornes du message." +"Si un processus est tué pendant qu'il essaye de lire ou écrire sur le tube, alors les données du tube ont des " +"chances d'être corrompues, parce qu'il devient impossible d'être sûr d'où se trouvent les bornes du message." #: library/multiprocessing.rst:1210 msgid "Synchronization primitives" @@ -1813,63 +1485,53 @@ msgstr "Primitives de synchronisation" #: library/multiprocessing.rst:1214 msgid "" -"Generally synchronization primitives are not as necessary in a multiprocess " -"program as they are in a multithreaded program. See the documentation for :" -"mod:`threading` module." +"Generally synchronization primitives are not as necessary in a multiprocess program as they are in a " +"multithreaded program. See the documentation for :mod:`threading` module." msgstr "" -"Généralement les primitives de synchronisation ne sont pas nécessaire dans " -"un programme multi-processus comme elles le sont dans un programme multi-" -"fils d'exécution. Voir la documentation du module :mod:`threading`." +"Généralement les primitives de synchronisation ne sont pas nécessaire dans un programme multi-processus comme " +"elles le sont dans un programme multi-fils d'exécution. Voir la documentation du module :mod:`threading`." #: library/multiprocessing.rst:1218 msgid "" -"Note that one can also create synchronization primitives by using a manager " -"object -- see :ref:`multiprocessing-managers`." +"Note that one can also create synchronization primitives by using a manager object -- see :ref:`multiprocessing-" +"managers`." msgstr "" -"Notez que vous pouvez aussi créer des primitives de synchronisation en " -"utilisant un objet gestionnaire – voir :ref:`multiprocessing-managers`." +"Notez que vous pouvez aussi créer des primitives de synchronisation en utilisant un objet gestionnaire – voir :" +"ref:`multiprocessing-managers`." #: library/multiprocessing.rst:1223 msgid "A barrier object: a clone of :class:`threading.Barrier`." msgstr "Un objet barrière : un clone de :class:`threading.Barrier`." #: library/multiprocessing.rst:1229 -msgid "" -"A bounded semaphore object: a close analog of :class:`threading." -"BoundedSemaphore`." -msgstr "" -"Un objet sémaphore lié : un analogue proche de :class:`threading." -"BoundedSemaphore`." +msgid "A bounded semaphore object: a close analog of :class:`threading.BoundedSemaphore`." +msgstr "Un objet sémaphore lié : un analogue proche de :class:`threading.BoundedSemaphore`." #: library/multiprocessing.rst:1232 library/multiprocessing.rst:1370 msgid "" -"A solitary difference from its close analog exists: its ``acquire`` method's " -"first argument is named *block*, as is consistent with :meth:`Lock.acquire`." +"A solitary difference from its close analog exists: its ``acquire`` method's first argument is named *block*, as " +"is consistent with :meth:`Lock.acquire`." msgstr "" -"Une seule différence existe avec son proche analogue : le premier argument " -"de sa méthode ``acquire`` est appelé *block*, pour la cohérence avec :meth:" -"`Lock.acquire`." +"Une seule différence existe avec son proche analogue : le premier argument de sa méthode ``acquire`` est appelé " +"*block*, pour la cohérence avec :meth:`Lock.acquire`." #: library/multiprocessing.rst:1236 msgid "" -"On Mac OS X, this is indistinguishable from :class:`Semaphore` because " -"``sem_getvalue()`` is not implemented on that platform." +"On Mac OS X, this is indistinguishable from :class:`Semaphore` because ``sem_getvalue()`` is not implemented on " +"that platform." msgstr "" -"Sur Mac OS X, elle n'est pas distinguable de la classe :class:`Semaphore` " -"parce que ``sem_getvalue()`` n'est pas implémentée sur cette plateforme." +"Sur Mac OS X, elle n'est pas distinguable de la classe :class:`Semaphore` parce que ``sem_getvalue()`` n'est pas " +"implémentée sur cette plateforme." #: library/multiprocessing.rst:1241 msgid "A condition variable: an alias for :class:`threading.Condition`." -msgstr "" -"Une variable conditionnelle : un alias pour :class:`threading.Condition`." +msgstr "Une variable conditionnelle : un alias pour :class:`threading.Condition`." #: library/multiprocessing.rst:1243 msgid "" -"If *lock* is specified then it should be a :class:`Lock` or :class:`RLock` " -"object from :mod:`multiprocessing`." +"If *lock* is specified then it should be a :class:`Lock` or :class:`RLock` object from :mod:`multiprocessing`." msgstr "" -"Si *lock* est spécifié il doit être un objet :class:`Lock` ou :class:`RLock` " -"du module :mod:`multiprocessing`." +"Si *lock* est spécifié il doit être un objet :class:`Lock` ou :class:`RLock` du module :mod:`multiprocessing`." #: library/multiprocessing.rst:1246 library/multiprocessing.rst:1780 msgid "The :meth:`~threading.Condition.wait_for` method was added." @@ -1881,40 +1543,32 @@ msgstr "Un clone de :class:`threading.Event`." #: library/multiprocessing.rst:1256 msgid "" -"A non-recursive lock object: a close analog of :class:`threading.Lock`. Once " -"a process or thread has acquired a lock, subsequent attempts to acquire it " -"from any process or thread will block until it is released; any process or " -"thread may release it. The concepts and behaviors of :class:`threading." -"Lock` as it applies to threads are replicated here in :class:" -"`multiprocessing.Lock` as it applies to either processes or threads, except " -"as noted." -msgstr "" -"Un verrou non récursif : un analogue proche de :class:`threading.Lock`. Une " -"fois que le processus ou le fil d'exécution a acquis un verrou, les " -"tentatives suivantes d'acquisition depuis n'importe quel processus ou fil " -"d'exécution bloqueront jusqu'à ce qu'il soit libéré ; n'importe quel " -"processus ou fil peut le libérer. Les concepts et comportements de :class:" -"`threading.Lock` qui s'appliquent aux fils d'exécution sont répliqués ici " -"dans :class:`multiprocessing.Lock` et s'appliquent aux processus et aux fils " -"d'exécution, à l'exception de ce qui est indiqué." +"A non-recursive lock object: a close analog of :class:`threading.Lock`. Once a process or thread has acquired a " +"lock, subsequent attempts to acquire it from any process or thread will block until it is released; any process " +"or thread may release it. The concepts and behaviors of :class:`threading.Lock` as it applies to threads are " +"replicated here in :class:`multiprocessing.Lock` as it applies to either processes or threads, except as noted." +msgstr "" +"Un verrou non récursif : un analogue proche de :class:`threading.Lock`. Une fois que le processus ou le fil " +"d'exécution a acquis un verrou, les tentatives suivantes d'acquisition depuis n'importe quel processus ou fil " +"d'exécution bloqueront jusqu'à ce qu'il soit libéré ; n'importe quel processus ou fil peut le libérer. Les " +"concepts et comportements de :class:`threading.Lock` qui s'appliquent aux fils d'exécution sont répliqués ici " +"dans :class:`multiprocessing.Lock` et s'appliquent aux processus et aux fils d'exécution, à l'exception de ce qui " +"est indiqué." #: library/multiprocessing.rst:1264 msgid "" -"Note that :class:`Lock` is actually a factory function which returns an " -"instance of ``multiprocessing.synchronize.Lock`` initialized with a default " -"context." +"Note that :class:`Lock` is actually a factory function which returns an instance of ``multiprocessing.synchronize." +"Lock`` initialized with a default context." msgstr "" -"Notez que :class:`Lock` est en fait une fonction *factory* qui renvoie une " -"instance de ``multiprocessing.synchronize.Lock`` initialisée avec un " -"contexte par défaut." +"Notez que :class:`Lock` est en fait une fonction *factory* qui renvoie une instance de ``multiprocessing." +"synchronize.Lock`` initialisée avec un contexte par défaut." #: library/multiprocessing.rst:1268 msgid "" -":class:`Lock` supports the :term:`context manager` protocol and thus may be " -"used in :keyword:`with` statements." +":class:`Lock` supports the :term:`context manager` protocol and thus may be used in :keyword:`with` statements." msgstr "" -":class:`Lock` supporte le protocole :term:`context manager` et peut ainsi " -"être utilisé avec une instruction :keyword:`with`." +":class:`Lock` supporte le protocole :term:`context manager` et peut ainsi être utilisé avec une instruction :" +"keyword:`with`." #: library/multiprocessing.rst:1273 library/multiprocessing.rst:1324 msgid "Acquire a lock, blocking or non-blocking." @@ -1922,178 +1576,144 @@ msgstr "Acquiert un verrou, bloquant ou non bloquant." #: library/multiprocessing.rst:1275 msgid "" -"With the *block* argument set to ``True`` (the default), the method call " -"will block until the lock is in an unlocked state, then set it to locked and " -"return ``True``. Note that the name of this first argument differs from " -"that in :meth:`threading.Lock.acquire`." +"With the *block* argument set to ``True`` (the default), the method call will block until the lock is in an " +"unlocked state, then set it to locked and return ``True``. Note that the name of this first argument differs " +"from that in :meth:`threading.Lock.acquire`." msgstr "" -"Avec l'argument *block* à ``True`` (par défaut), l'appel de méthode bloquera " -"jusqu'à ce que le verrou soit dans déverrouillé, puis le verrouillera avant " -"de renvoyer ``True``. Notez que le nom de ce premier argument diffère de " +"Avec l'argument *block* à ``True`` (par défaut), l'appel de méthode bloquera jusqu'à ce que le verrou soit dans " +"déverrouillé, puis le verrouillera avant de renvoyer ``True``. Notez que le nom de ce premier argument diffère de " "celui de :meth:`threading.Lock.acquire`." #: library/multiprocessing.rst:1280 msgid "" -"With the *block* argument set to ``False``, the method call does not block. " -"If the lock is currently in a locked state, return ``False``; otherwise set " -"the lock to a locked state and return ``True``." +"With the *block* argument set to ``False``, the method call does not block. If the lock is currently in a locked " +"state, return ``False``; otherwise set the lock to a locked state and return ``True``." msgstr "" -"Avec l'argument *block* à ``False``, l'appel de méthode ne bloque pas. Si le " -"verrou est actuellement verrouillé, renvoie ``False`` ; autrement verrouille " -"le verrou et renvoie ``True``." +"Avec l'argument *block* à ``False``, l'appel de méthode ne bloque pas. Si le verrou est actuellement verrouillé, " +"renvoie ``False`` ; autrement verrouille le verrou et renvoie ``True``." #: library/multiprocessing.rst:1284 msgid "" -"When invoked with a positive, floating-point value for *timeout*, block for " -"at most the number of seconds specified by *timeout* as long as the lock can " -"not be acquired. Invocations with a negative value for *timeout* are " -"equivalent to a *timeout* of zero. Invocations with a *timeout* value of " -"``None`` (the default) set the timeout period to infinite. Note that the " -"treatment of negative or ``None`` values for *timeout* differs from the " -"implemented behavior in :meth:`threading.Lock.acquire`. The *timeout* " -"argument has no practical implications if the *block* argument is set to " -"``False`` and is thus ignored. Returns ``True`` if the lock has been " -"acquired or ``False`` if the timeout period has elapsed." -msgstr "" -"Quand invoqué avec un nombre flottant positif comme *timeout*, bloque au " -"maximum pendant ce nombre spécifié de secondes, tant que le verrou ne peut " -"être acquis. Les invocations avec une valeur de *timeout* négatives sont " -"équivalents à zéro. Les invocations avec un *timeout* à ``None`` (par " -"défaut) correspondent à un délai d'attente infini. Notez que le traitement " -"des valeurs de *timeout* négatives et ``None`` diffère du comportement " -"implémenté dans :meth:`threading.Lock.acquire`. L'argument *timeout* n'a pas " -"d'implication pratique si l'argument *block* est mis ) ``False`` et est " -"alors ignoré. Renvoie ``True`` si le verrou a été acquis et ``False`` si le " -"temps de *timeout* a expiré." +"When invoked with a positive, floating-point value for *timeout*, block for at most the number of seconds " +"specified by *timeout* as long as the lock can not be acquired. Invocations with a negative value for *timeout* " +"are equivalent to a *timeout* of zero. Invocations with a *timeout* value of ``None`` (the default) set the " +"timeout period to infinite. Note that the treatment of negative or ``None`` values for *timeout* differs from " +"the implemented behavior in :meth:`threading.Lock.acquire`. The *timeout* argument has no practical implications " +"if the *block* argument is set to ``False`` and is thus ignored. Returns ``True`` if the lock has been acquired " +"or ``False`` if the timeout period has elapsed." +msgstr "" +"Quand invoqué avec un nombre flottant positif comme *timeout*, bloque au maximum pendant ce nombre spécifié de " +"secondes, tant que le verrou ne peut être acquis. Les invocations avec une valeur de *timeout* négatives sont " +"équivalents à zéro. Les invocations avec un *timeout* à ``None`` (par défaut) correspondent à un délai d'attente " +"infini. Notez que le traitement des valeurs de *timeout* négatives et ``None`` diffère du comportement implémenté " +"dans :meth:`threading.Lock.acquire`. L'argument *timeout* n'a pas d'implication pratique si l'argument *block* " +"est mis ) ``False`` et est alors ignoré. Renvoie ``True`` si le verrou a été acquis et ``False`` si le temps de " +"*timeout* a expiré." #: library/multiprocessing.rst:1299 msgid "" -"Release a lock. This can be called from any process or thread, not only the " -"process or thread which originally acquired the lock." +"Release a lock. This can be called from any process or thread, not only the process or thread which originally " +"acquired the lock." msgstr "" -"Libère un verrou. Elle peut être appelée depuis n'importe quel processus ou " -"fil d'exécution, pas uniquement le processus ou le fil qui a acquis le " -"verrou à l'origine." +"Libère un verrou. Elle peut être appelée depuis n'importe quel processus ou fil d'exécution, pas uniquement le " +"processus ou le fil qui a acquis le verrou à l'origine." #: library/multiprocessing.rst:1302 msgid "" -"Behavior is the same as in :meth:`threading.Lock.release` except that when " -"invoked on an unlocked lock, a :exc:`ValueError` is raised." +"Behavior is the same as in :meth:`threading.Lock.release` except that when invoked on an unlocked lock, a :exc:" +"`ValueError` is raised." msgstr "" -"Le comportement est le même que :meth:`threading.Lock.release` excepté que " -"lorsque la méthode est appelée sur un verrou déverrouillé, une :exc:" -"`ValueError` est levée." +"Le comportement est le même que :meth:`threading.Lock.release` excepté que lorsque la méthode est appelée sur un " +"verrou déverrouillé, une :exc:`ValueError` est levée." #: library/multiprocessing.rst:1308 msgid "" -"A recursive lock object: a close analog of :class:`threading.RLock`. A " -"recursive lock must be released by the process or thread that acquired it. " -"Once a process or thread has acquired a recursive lock, the same process or " -"thread may acquire it again without blocking; that process or thread must " -"release it once for each time it has been acquired." +"A recursive lock object: a close analog of :class:`threading.RLock`. A recursive lock must be released by the " +"process or thread that acquired it. Once a process or thread has acquired a recursive lock, the same process or " +"thread may acquire it again without blocking; that process or thread must release it once for each time it has " +"been acquired." msgstr "" -"Un objet verrou récursif : un analogue proche de :class:`threading.RLock`. " -"Un verrou récursif doit être libéré par le processus ou le fil d'exécution " -"qui l'a acquis. Quand un processus ou un fil acquiert un verrou récursif, le " -"même processus/fil peut l'acquérir à nouveau sans bloquer ; le processus/fil " -"doit le libérer autant de fois qu'il l'acquiert." +"Un objet verrou récursif : un analogue proche de :class:`threading.RLock`. Un verrou récursif doit être libéré " +"par le processus ou le fil d'exécution qui l'a acquis. Quand un processus ou un fil acquiert un verrou récursif, " +"le même processus/fil peut l'acquérir à nouveau sans bloquer ; le processus/fil doit le libérer autant de fois " +"qu'il l'acquiert." #: library/multiprocessing.rst:1314 msgid "" -"Note that :class:`RLock` is actually a factory function which returns an " -"instance of ``multiprocessing.synchronize.RLock`` initialized with a default " -"context." +"Note that :class:`RLock` is actually a factory function which returns an instance of ``multiprocessing." +"synchronize.RLock`` initialized with a default context." msgstr "" -"Notez que :class:`RLock` est en fait une fonction *factory* qui renvoie une " -"instance de ``multiprocessing.synchronize.RLock`` initialisée avec un " -"contexte par défaut." +"Notez que :class:`RLock` est en fait une fonction *factory* qui renvoie une instance de ``multiprocessing." +"synchronize.RLock`` initialisée avec un contexte par défaut." #: library/multiprocessing.rst:1318 msgid "" -":class:`RLock` supports the :term:`context manager` protocol and thus may be " -"used in :keyword:`with` statements." +":class:`RLock` supports the :term:`context manager` protocol and thus may be used in :keyword:`with` statements." msgstr "" -":class:`RLock` supporte le protocole :term:`context manager` et peut ainsi " -"être utilisée avec une instruction :keyword:`with`." +":class:`RLock` supporte le protocole :term:`context manager` et peut ainsi être utilisée avec une instruction :" +"keyword:`with`." #: library/multiprocessing.rst:1326 msgid "" -"When invoked with the *block* argument set to ``True``, block until the lock " -"is in an unlocked state (not owned by any process or thread) unless the lock " -"is already owned by the current process or thread. The current process or " -"thread then takes ownership of the lock (if it does not already have " -"ownership) and the recursion level inside the lock increments by one, " -"resulting in a return value of ``True``. Note that there are several " -"differences in this first argument's behavior compared to the implementation " -"of :meth:`threading.RLock.acquire`, starting with the name of the argument " -"itself." -msgstr "" -"Quand invoqué avec l'argument *block* à ``True``, bloque jusqu'à ce que le " -"verrou soit déverrouillé (n'appartenant à aucun processus ou fil " -"d'exécution) sauf s'il appartient déjà au processus ou fil d'exécution " -"courant. Le processus ou fil d'exécution courant prend la possession du " -"verrou (s'il ne l'a pas déjà) et incrémente d'un le niveau de récursion du " -"verrou, renvoyant ainsi ``True``. Notez qu'il y a plusieurs différences dans " -"le comportement de ce premier argument comparé à l'implémentation de :meth:" -"`threading.RLock.acquire`, à commencer par le nom de l'argument lui-même." +"When invoked with the *block* argument set to ``True``, block until the lock is in an unlocked state (not owned " +"by any process or thread) unless the lock is already owned by the current process or thread. The current process " +"or thread then takes ownership of the lock (if it does not already have ownership) and the recursion level inside " +"the lock increments by one, resulting in a return value of ``True``. Note that there are several differences in " +"this first argument's behavior compared to the implementation of :meth:`threading.RLock.acquire`, starting with " +"the name of the argument itself." +msgstr "" +"Quand invoqué avec l'argument *block* à ``True``, bloque jusqu'à ce que le verrou soit déverrouillé " +"(n'appartenant à aucun processus ou fil d'exécution) sauf s'il appartient déjà au processus ou fil d'exécution " +"courant. Le processus ou fil d'exécution courant prend la possession du verrou (s'il ne l'a pas déjà) et " +"incrémente d'un le niveau de récursion du verrou, renvoyant ainsi ``True``. Notez qu'il y a plusieurs différences " +"dans le comportement de ce premier argument comparé à l'implémentation de :meth:`threading.RLock.acquire`, à " +"commencer par le nom de l'argument lui-même." #: library/multiprocessing.rst:1336 msgid "" -"When invoked with the *block* argument set to ``False``, do not block. If " -"the lock has already been acquired (and thus is owned) by another process or " -"thread, the current process or thread does not take ownership and the " -"recursion level within the lock is not changed, resulting in a return value " -"of ``False``. If the lock is in an unlocked state, the current process or " -"thread takes ownership and the recursion level is incremented, resulting in " -"a return value of ``True``." -msgstr "" -"Quand invoqué avec l'argument *block* à ``False``, ne bloque pas. Si le " -"verrou est déjà acquis (et possédé) par un autre processus ou fil " -"d'exécution, le processus/fil courant n'en prend pas la possession et le " -"niveau de récursion n'est pas incrémenté, résultant en une valeur de retour " -"à ``False``. Si le verrou est déverrouillé, le processus/fil courant en " -"prend possession et incrémente son niveau de récursion, renvoyant ``True``." +"When invoked with the *block* argument set to ``False``, do not block. If the lock has already been acquired (and " +"thus is owned) by another process or thread, the current process or thread does not take ownership and the " +"recursion level within the lock is not changed, resulting in a return value of ``False``. If the lock is in an " +"unlocked state, the current process or thread takes ownership and the recursion level is incremented, resulting " +"in a return value of ``True``." +msgstr "" +"Quand invoqué avec l'argument *block* à ``False``, ne bloque pas. Si le verrou est déjà acquis (et possédé) par " +"un autre processus ou fil d'exécution, le processus/fil courant n'en prend pas la possession et le niveau de " +"récursion n'est pas incrémenté, résultant en une valeur de retour à ``False``. Si le verrou est déverrouillé, le " +"processus/fil courant en prend possession et incrémente son niveau de récursion, renvoyant ``True``." #: library/multiprocessing.rst:1344 msgid "" -"Use and behaviors of the *timeout* argument are the same as in :meth:`Lock." -"acquire`. Note that some of these behaviors of *timeout* differ from the " -"implemented behaviors in :meth:`threading.RLock.acquire`." +"Use and behaviors of the *timeout* argument are the same as in :meth:`Lock.acquire`. Note that some of these " +"behaviors of *timeout* differ from the implemented behaviors in :meth:`threading.RLock.acquire`." msgstr "" -"L'usage et les comportements de l'argument *timeout* sont les mêmes que " -"pour :meth:`Lock.acquire`. Notez que certains de ces comportements diffèrent " -"par rapport à ceux implémentés par :meth:`threading.RLock.acquire`." +"L'usage et les comportements de l'argument *timeout* sont les mêmes que pour :meth:`Lock.acquire`. Notez que " +"certains de ces comportements diffèrent par rapport à ceux implémentés par :meth:`threading.RLock.acquire`." #: library/multiprocessing.rst:1351 msgid "" -"Release a lock, decrementing the recursion level. If after the decrement " -"the recursion level is zero, reset the lock to unlocked (not owned by any " -"process or thread) and if any other processes or threads are blocked waiting " -"for the lock to become unlocked, allow exactly one of them to proceed. If " -"after the decrement the recursion level is still nonzero, the lock remains " -"locked and owned by the calling process or thread." -msgstr "" -"Libère un verrou, décrémentant son niveau de récursion. Si après la " -"décrémentation le niveau de récursion est zéro, réinitialise le verrou à un " -"état déverrouillé (n'appartenant à aucun processus ou fil d'exécution) et si " -"des processus/fils attendent que le verrou se déverrouillé, autorise un seul " -"d'entre-eux à continuer. Si après cette décrémentation le niveau de " -"récursion est toujours strictement positif, le verrou reste verrouillé et " +"Release a lock, decrementing the recursion level. If after the decrement the recursion level is zero, reset the " +"lock to unlocked (not owned by any process or thread) and if any other processes or threads are blocked waiting " +"for the lock to become unlocked, allow exactly one of them to proceed. If after the decrement the recursion " +"level is still nonzero, the lock remains locked and owned by the calling process or thread." +msgstr "" +"Libère un verrou, décrémentant son niveau de récursion. Si après la décrémentation le niveau de récursion est " +"zéro, réinitialise le verrou à un état déverrouillé (n'appartenant à aucun processus ou fil d'exécution) et si " +"des processus/fils attendent que le verrou se déverrouillé, autorise un seul d'entre-eux à continuer. Si après " +"cette décrémentation le niveau de récursion est toujours strictement positif, le verrou reste verrouillé et " "propriété du processus/fil appelant." #: library/multiprocessing.rst:1359 msgid "" -"Only call this method when the calling process or thread owns the lock. An :" -"exc:`AssertionError` is raised if this method is called by a process or " -"thread other than the owner or if the lock is in an unlocked (unowned) " -"state. Note that the type of exception raised in this situation differs " -"from the implemented behavior in :meth:`threading.RLock.release`." +"Only call this method when the calling process or thread owns the lock. An :exc:`AssertionError` is raised if " +"this method is called by a process or thread other than the owner or if the lock is in an unlocked (unowned) " +"state. Note that the type of exception raised in this situation differs from the implemented behavior in :meth:" +"`threading.RLock.release`." msgstr "" -"N'appelez cette méthode que si le processus ou fil d'exécution appelant est " -"propriétaire du verrou. Une :exc:`AssertionError` est levée si cette méthode " -"est appelée par un processus/fil autre que le propriétaire ou si le verrou " -"n'est pas verrouillé (possédé). Notez que le type d'exception levé dans " -"cette situation diffère du comportement de :meth:`threading.RLock.release`." +"N'appelez cette méthode que si le processus ou fil d'exécution appelant est propriétaire du verrou. Une :exc:" +"`AssertionError` est levée si cette méthode est appelée par un processus/fil autre que le propriétaire ou si le " +"verrou n'est pas verrouillé (possédé). Notez que le type d'exception levé dans cette situation diffère du " +"comportement de :meth:`threading.RLock.release`." #: library/multiprocessing.rst:1368 msgid "A semaphore object: a close analog of :class:`threading.Semaphore`." @@ -2101,161 +1721,131 @@ msgstr "Un objet sémaphore, proche analogue de :class:`threading.Semaphore`." #: library/multiprocessing.rst:1375 msgid "" -"On Mac OS X, ``sem_timedwait`` is unsupported, so calling ``acquire()`` with " -"a timeout will emulate that function's behavior using a sleeping loop." +"On Mac OS X, ``sem_timedwait`` is unsupported, so calling ``acquire()`` with a timeout will emulate that " +"function's behavior using a sleeping loop." msgstr "" -"Sous Mac OS X, ``sem_timedwait`` n'est pas supporté, donc appeler " -"``acquire()`` avec un temps d'exécution limité émulera le comportement de " -"cette fonction en utilisant une boucle d'attente." +"Sous Mac OS X, ``sem_timedwait`` n'est pas supporté, donc appeler ``acquire()`` avec un temps d'exécution limité " +"émulera le comportement de cette fonction en utilisant une boucle d'attente." #: library/multiprocessing.rst:1380 msgid "" -"If the SIGINT signal generated by :kbd:`Ctrl-C` arrives while the main " -"thread is blocked by a call to :meth:`BoundedSemaphore.acquire`, :meth:`Lock." -"acquire`, :meth:`RLock.acquire`, :meth:`Semaphore.acquire`, :meth:`Condition." -"acquire` or :meth:`Condition.wait` then the call will be immediately " -"interrupted and :exc:`KeyboardInterrupt` will be raised." +"If the SIGINT signal generated by :kbd:`Ctrl-C` arrives while the main thread is blocked by a call to :meth:" +"`BoundedSemaphore.acquire`, :meth:`Lock.acquire`, :meth:`RLock.acquire`, :meth:`Semaphore.acquire`, :meth:" +"`Condition.acquire` or :meth:`Condition.wait` then the call will be immediately interrupted and :exc:" +"`KeyboardInterrupt` will be raised." msgstr "" -"Si le signal *SIGINT* généré par un :kbd:`Ctrl-C` survient pendant que le " -"fil d'exécution principal est bloqué par un appel à :meth:`BoundedSemaphore." -"acquire`, :meth:`Lock.acquire`, :meth:`RLock.acquire`, :meth:`Semaphore." -"acquire`, :meth:`Condition.acquire` ou :meth:`Condition.wait`, l'appel sera " -"immédiatement interrompu et une :exc:`KeyboardInterrupt` sera levée." +"Si le signal *SIGINT* généré par un :kbd:`Ctrl-C` survient pendant que le fil d'exécution principal est bloqué " +"par un appel à :meth:`BoundedSemaphore.acquire`, :meth:`Lock.acquire`, :meth:`RLock.acquire`, :meth:`Semaphore." +"acquire`, :meth:`Condition.acquire` ou :meth:`Condition.wait`, l'appel sera immédiatement interrompu et une :exc:" +"`KeyboardInterrupt` sera levée." #: library/multiprocessing.rst:1386 msgid "" -"This differs from the behaviour of :mod:`threading` where SIGINT will be " -"ignored while the equivalent blocking calls are in progress." +"This differs from the behaviour of :mod:`threading` where SIGINT will be ignored while the equivalent blocking " +"calls are in progress." msgstr "" -"Cela diffère du comportement de :mod:`threading` où le *SIGINT* est ignoré " -"tant que les appels bloquants sont en cours." +"Cela diffère du comportement de :mod:`threading` où le *SIGINT* est ignoré tant que les appels bloquants sont en " +"cours." #: library/multiprocessing.rst:1391 msgid "" -"Some of this package's functionality requires a functioning shared semaphore " -"implementation on the host operating system. Without one, the :mod:" -"`multiprocessing.synchronize` module will be disabled, and attempts to " -"import it will result in an :exc:`ImportError`. See :issue:`3770` for " -"additional information." +"Some of this package's functionality requires a functioning shared semaphore implementation on the host operating " +"system. Without one, the :mod:`multiprocessing.synchronize` module will be disabled, and attempts to import it " +"will result in an :exc:`ImportError`. See :issue:`3770` for additional information." msgstr "" -"Certaines des fonctionnalités de ce paquet requièrent une implémentation " -"fonctionnelle de sémaphores partagés sur le système hôte. Sans cela, le " -"module :mod:`multiprocessing.synchronize` sera désactivé, et les tentatives " -"de l'importer lèveront une :exc:`ImportError`. Voir :issue:`3770` pour plus " -"d'informations." +"Certaines des fonctionnalités de ce paquet requièrent une implémentation fonctionnelle de sémaphores partagés sur " +"le système hôte. Sans cela, le module :mod:`multiprocessing.synchronize` sera désactivé, et les tentatives de " +"l'importer lèveront une :exc:`ImportError`. Voir :issue:`3770` pour plus d'informations." #: library/multiprocessing.rst:1399 msgid "Shared :mod:`ctypes` Objects" msgstr "Objets :mod:`ctypes` partagés" #: library/multiprocessing.rst:1401 -msgid "" -"It is possible to create shared objects using shared memory which can be " -"inherited by child processes." +msgid "It is possible to create shared objects using shared memory which can be inherited by child processes." msgstr "" -"Il est possible de créer des objets partagés utilisant une mémoire partagée " -"pouvant être héritée par les processus enfants." +"Il est possible de créer des objets partagés utilisant une mémoire partagée pouvant être héritée par les " +"processus enfants." #: library/multiprocessing.rst:1406 msgid "" -"Return a :mod:`ctypes` object allocated from shared memory. By default the " -"return value is actually a synchronized wrapper for the object. The object " -"itself can be accessed via the *value* attribute of a :class:`Value`." -msgstr "" -"Renvoie un objet :mod:`ctypes` alloué depuis la mémoire partagée. Par défaut " -"la valeur de retour est en fait un *wrapper* synchronisé autour de l'objet. " -"L'objet en lui-même est accessible par l'attribut *value* de l'une :class:" +"Return a :mod:`ctypes` object allocated from shared memory. By default the return value is actually a " +"synchronized wrapper for the object. The object itself can be accessed via the *value* attribute of a :class:" "`Value`." +msgstr "" +"Renvoie un objet :mod:`ctypes` alloué depuis la mémoire partagée. Par défaut la valeur de retour est en fait un " +"*wrapper* synchronisé autour de l'objet. L'objet en lui-même est accessible par l'attribut *value* de l'une :" +"class:`Value`." #: library/multiprocessing.rst:1410 library/multiprocessing.rst:1497 msgid "" -"*typecode_or_type* determines the type of the returned object: it is either " -"a ctypes type or a one character typecode of the kind used by the :mod:" -"`array` module. *\\*args* is passed on to the constructor for the type." +"*typecode_or_type* determines the type of the returned object: it is either a ctypes type or a one character " +"typecode of the kind used by the :mod:`array` module. *\\*args* is passed on to the constructor for the type." msgstr "" -"*typecode_or_type* détermine le type de l'objet renvoyé : il s'agit soit " -"d'un type *ctype* soit d'un caractère *typecode* tel qu'utilisé par le " -"module :mod:`array`. *\\*args* est passé au constructeur de ce type." +"*typecode_or_type* détermine le type de l'objet renvoyé : il s'agit soit d'un type *ctype* soit d'un caractère " +"*typecode* tel qu'utilisé par le module :mod:`array`. *\\*args* est passé au constructeur de ce type." #: library/multiprocessing.rst:1414 msgid "" -"If *lock* is ``True`` (the default) then a new recursive lock object is " -"created to synchronize access to the value. If *lock* is a :class:`Lock` " -"or :class:`RLock` object then that will be used to synchronize access to the " -"value. If *lock* is ``False`` then access to the returned object will not " -"be automatically protected by a lock, so it will not necessarily be " -"\"process-safe\"." +"If *lock* is ``True`` (the default) then a new recursive lock object is created to synchronize access to the " +"value. If *lock* is a :class:`Lock` or :class:`RLock` object then that will be used to synchronize access to the " +"value. If *lock* is ``False`` then access to the returned object will not be automatically protected by a lock, " +"so it will not necessarily be \"process-safe\"." msgstr "" -"Si *lock* vaut ``True`` (par défaut), alors un nouveau verrou récursif est " -"créé pour synchroniser l'accès à la valeur. Si *lock* est un objet :class:" -"`Lock` ou :class:`RLock` alors il sera utilisé pour synchroniser l'accès à " -"la valeur. Si *lock* vaut ``False``, l'accès à l'objet renvoyé ne sera pas " -"automatiquement protégé par un verrou, donc il ne sera pas forcément " -"« *process-safe* »." +"Si *lock* vaut ``True`` (par défaut), alors un nouveau verrou récursif est créé pour synchroniser l'accès à la " +"valeur. Si *lock* est un objet :class:`Lock` ou :class:`RLock` alors il sera utilisé pour synchroniser l'accès à " +"la valeur. Si *lock* vaut ``False``, l'accès à l'objet renvoyé ne sera pas automatiquement protégé par un verrou, " +"donc il ne sera pas forcément « *process-safe* »." #: library/multiprocessing.rst:1421 msgid "" -"Operations like ``+=`` which involve a read and write are not atomic. So " -"if, for instance, you want to atomically increment a shared value it is " -"insufficient to just do ::" +"Operations like ``+=`` which involve a read and write are not atomic. So if, for instance, you want to " +"atomically increment a shared value it is insufficient to just do ::" msgstr "" -"Les opérations telles que ``+=`` qui impliquent une lecture et une écriture " -"ne sont pas atomique. Ainsi si vous souhaitez par exemple réaliser une " -"incrémentation atomique sur une valeur partagée, vous ne pouvez pas " -"simplement faire ::" +"Les opérations telles que ``+=`` qui impliquent une lecture et une écriture ne sont pas atomique. Ainsi si vous " +"souhaitez par exemple réaliser une incrémentation atomique sur une valeur partagée, vous ne pouvez pas simplement " +"faire ::" #: library/multiprocessing.rst:1427 -msgid "" -"Assuming the associated lock is recursive (which it is by default) you can " -"instead do ::" +msgid "Assuming the associated lock is recursive (which it is by default) you can instead do ::" msgstr "" -"En supposant que le verrou associé est récursif (ce qui est le cas par " -"défaut), vous pouvez à la place faire ::" +"En supposant que le verrou associé est récursif (ce qui est le cas par défaut), vous pouvez à la place faire ::" -#: library/multiprocessing.rst:1433 library/multiprocessing.rst:1523 -#: library/multiprocessing.rst:1538 +#: library/multiprocessing.rst:1433 library/multiprocessing.rst:1523 library/multiprocessing.rst:1538 msgid "Note that *lock* is a keyword-only argument." msgstr "Notez que *lock* est un argument *keyword-only*." #: library/multiprocessing.rst:1437 msgid "" -"Return a ctypes array allocated from shared memory. By default the return " -"value is actually a synchronized wrapper for the array." +"Return a ctypes array allocated from shared memory. By default the return value is actually a synchronized " +"wrapper for the array." msgstr "" -"Renvoie un tableau *ctypes* alloué depuis la mémoire partagée. Par défaut la " -"valeur de retour est en fait un *wrapper* synchronisé autour du tableau." +"Renvoie un tableau *ctypes* alloué depuis la mémoire partagée. Par défaut la valeur de retour est en fait un " +"*wrapper* synchronisé autour du tableau." #: library/multiprocessing.rst:1440 msgid "" -"*typecode_or_type* determines the type of the elements of the returned " -"array: it is either a ctypes type or a one character typecode of the kind " -"used by the :mod:`array` module. If *size_or_initializer* is an integer, " -"then it determines the length of the array, and the array will be initially " -"zeroed. Otherwise, *size_or_initializer* is a sequence which is used to " -"initialize the array and whose length determines the length of the array." +"*typecode_or_type* determines the type of the elements of the returned array: it is either a ctypes type or a one " +"character typecode of the kind used by the :mod:`array` module. If *size_or_initializer* is an integer, then it " +"determines the length of the array, and the array will be initially zeroed. Otherwise, *size_or_initializer* is a " +"sequence which is used to initialize the array and whose length determines the length of the array." msgstr "" -"*typecode_or_type* détermine le type des éléments du tableau renvoyé : il " -"s'agit soit d'un type *ctype* soit d'un caractère *typecode* tel qu'utilisé " -"par le module :mod:`array`. Si *size_or_initialize* est un entier, alors il " -"détermine la taille du tableau, et le tableau sera initialisé avec des " -"zéros. Autrement, *size*or_initializer* est une séquence qui sera utilisée " -"pour initialiser le tableau et dont la taille détermine celle du tableau." +"*typecode_or_type* détermine le type des éléments du tableau renvoyé : il s'agit soit d'un type *ctype* soit d'un " +"caractère *typecode* tel qu'utilisé par le module :mod:`array`. Si *size_or_initialize* est un entier, alors il " +"détermine la taille du tableau, et le tableau sera initialisé avec des zéros. Autrement, *size*or_initializer* " +"est une séquence qui sera utilisée pour initialiser le tableau et dont la taille détermine celle du tableau." #: library/multiprocessing.rst:1447 msgid "" -"If *lock* is ``True`` (the default) then a new lock object is created to " -"synchronize access to the value. If *lock* is a :class:`Lock` or :class:" -"`RLock` object then that will be used to synchronize access to the value. " -"If *lock* is ``False`` then access to the returned object will not be " -"automatically protected by a lock, so it will not necessarily be \"process-" -"safe\"." +"If *lock* is ``True`` (the default) then a new lock object is created to synchronize access to the value. If " +"*lock* is a :class:`Lock` or :class:`RLock` object then that will be used to synchronize access to the value. If " +"*lock* is ``False`` then access to the returned object will not be automatically protected by a lock, so it will " +"not necessarily be \"process-safe\"." msgstr "" -"Si *lock* vaut ``True`` (par défaut), alors un nouveau verrou est créé pour " -"synchroniser l'accès à la valeur. Si *lock* est un objet :class:`Lock` ou :" -"class:`RLock` alors il sera utilisé pour synchroniser l'accès à la valeur. " -"Si *lock* vaut ``False``, l'accès à l'objet renvoyé ne sera pas " -"automatiquement protégé par un verrou, donc il ne sera pas forcément " -"« *process-safe* »." +"Si *lock* vaut ``True`` (par défaut), alors un nouveau verrou est créé pour synchroniser l'accès à la valeur. Si " +"*lock* est un objet :class:`Lock` ou :class:`RLock` alors il sera utilisé pour synchroniser l'accès à la valeur. " +"Si *lock* vaut ``False``, l'accès à l'objet renvoyé ne sera pas automatiquement protégé par un verrou, donc il ne " +"sera pas forcément « *process-safe* »." #: library/multiprocessing.rst:1454 msgid "Note that *lock* is a keyword only argument." @@ -2263,12 +1853,11 @@ msgstr "Notez que *lock* est un argument *keyword-only*." #: library/multiprocessing.rst:1456 msgid "" -"Note that an array of :data:`ctypes.c_char` has *value* and *raw* attributes " -"which allow one to use it to store and retrieve strings." +"Note that an array of :data:`ctypes.c_char` has *value* and *raw* attributes which allow one to use it to store " +"and retrieve strings." msgstr "" -"Notez qu'un tableau de :data:`ctypes.c_char` a ses attributs *value* et " -"*raw* qui permettent de l'utiliser pour stocker et récupérer des chaînes de " -"caractères." +"Notez qu'un tableau de :data:`ctypes.c_char` a ses attributs *value* et *raw* qui permettent de l'utiliser pour " +"stocker et récupérer des chaînes de caractères." #: library/multiprocessing.rst:1461 msgid "The :mod:`multiprocessing.sharedctypes` module" @@ -2276,27 +1865,22 @@ msgstr "Le module :mod:`multiprocessing.sharedctypes`" #: library/multiprocessing.rst:1466 msgid "" -"The :mod:`multiprocessing.sharedctypes` module provides functions for " -"allocating :mod:`ctypes` objects from shared memory which can be inherited " -"by child processes." +"The :mod:`multiprocessing.sharedctypes` module provides functions for allocating :mod:`ctypes` objects from " +"shared memory which can be inherited by child processes." msgstr "" -"Le module :mod:`multiprocessing.sharedctypes` fournit des fonctions pour " -"allouer des objets :mod:`ctypes` depuis la mémoire partagée, qui peuvent " -"être hérités par les processus fils." +"Le module :mod:`multiprocessing.sharedctypes` fournit des fonctions pour allouer des objets :mod:`ctypes` depuis " +"la mémoire partagée, qui peuvent être hérités par les processus fils." #: library/multiprocessing.rst:1472 msgid "" -"Although it is possible to store a pointer in shared memory remember that " -"this will refer to a location in the address space of a specific process. " -"However, the pointer is quite likely to be invalid in the context of a " -"second process and trying to dereference the pointer from the second process " -"may cause a crash." +"Although it is possible to store a pointer in shared memory remember that this will refer to a location in the " +"address space of a specific process. However, the pointer is quite likely to be invalid in the context of a " +"second process and trying to dereference the pointer from the second process may cause a crash." msgstr "" -"Bien qu'il soit possible de stocker un pointeur en mémoire partagée, " -"rappelez-vous qu'un pointer référence un emplacement dans l'espace " -"d'adressage d'un processus particulier. Ainsi, ce pointeur a de fortes " -"chances d'être invalide dans le contexte d'un autre processus et " -"déréférencer le pointeur depuis ce second processus peut causer un plantage." +"Bien qu'il soit possible de stocker un pointeur en mémoire partagée, rappelez-vous qu'un pointer référence un " +"emplacement dans l'espace d'adressage d'un processus particulier. Ainsi, ce pointeur a de fortes chances d'être " +"invalide dans le contexte d'un autre processus et déréférencer le pointeur depuis ce second processus peut causer " +"un plantage." #: library/multiprocessing.rst:1480 msgid "Return a ctypes array allocated from shared memory." @@ -2304,30 +1888,24 @@ msgstr "Renvoie un tableau *ctypes* alloué depuis la mémoire partagée." #: library/multiprocessing.rst:1482 msgid "" -"*typecode_or_type* determines the type of the elements of the returned " -"array: it is either a ctypes type or a one character typecode of the kind " -"used by the :mod:`array` module. If *size_or_initializer* is an integer " -"then it determines the length of the array, and the array will be initially " -"zeroed. Otherwise *size_or_initializer* is a sequence which is used to " -"initialize the array and whose length determines the length of the array." -msgstr "" -"*typecode_or_type* détermine le type des éléments du tableau renvoyé : il " -"s'agit soit d'un type *ctype* soit d'un caractère codant le type des " -"éléments du tableau (*typecode*) tel qu'utilisé par le module :mod:`array`. " -"Si *size_or_initialize* est un entier, alors il détermine la taille du " -"tableau, et le tableau sera initialisé avec des zéros. Autrement, " -"*size_or_initializer* est une séquence qui sera utilisée pour initialiser le " -"tableau et dont la taille détermine celle du tableau." +"*typecode_or_type* determines the type of the elements of the returned array: it is either a ctypes type or a one " +"character typecode of the kind used by the :mod:`array` module. If *size_or_initializer* is an integer then it " +"determines the length of the array, and the array will be initially zeroed. Otherwise *size_or_initializer* is a " +"sequence which is used to initialize the array and whose length determines the length of the array." +msgstr "" +"*typecode_or_type* détermine le type des éléments du tableau renvoyé : il s'agit soit d'un type *ctype* soit d'un " +"caractère codant le type des éléments du tableau (*typecode*) tel qu'utilisé par le module :mod:`array`. Si " +"*size_or_initialize* est un entier, alors il détermine la taille du tableau, et le tableau sera initialisé avec " +"des zéros. Autrement, *size_or_initializer* est une séquence qui sera utilisée pour initialiser le tableau et " +"dont la taille détermine celle du tableau." #: library/multiprocessing.rst:1489 msgid "" -"Note that setting and getting an element is potentially non-atomic -- use :" -"func:`Array` instead to make sure that access is automatically synchronized " -"using a lock." +"Note that setting and getting an element is potentially non-atomic -- use :func:`Array` instead to make sure that " +"access is automatically synchronized using a lock." msgstr "" -"Notez que définir ou récupérer un élément est potentiellement non atomique – " -"utilisez plutôt :func:`Array` pour vous assurer de synchroniser " -"automatiquement avec un verrou." +"Notez que définir ou récupérer un élément est potentiellement non atomique – utilisez plutôt :func:`Array` pour " +"vous assurer de synchroniser automatiquement avec un verrou." #: library/multiprocessing.rst:1495 msgid "Return a ctypes object allocated from shared memory." @@ -2335,110 +1913,87 @@ msgstr "Renvoie un objet *ctypes* alloué depuis la mémoire partagée." #: library/multiprocessing.rst:1501 msgid "" -"Note that setting and getting the value is potentially non-atomic -- use :" -"func:`Value` instead to make sure that access is automatically synchronized " -"using a lock." +"Note that setting and getting the value is potentially non-atomic -- use :func:`Value` instead to make sure that " +"access is automatically synchronized using a lock." msgstr "" -"Notez que définir ou récupérer un élément est potentiellement non atomique – " -"utilisez plutôt :func:`Value` pour vous assurer de synchroniser " -"automatiquement avec un verrou." +"Notez que définir ou récupérer un élément est potentiellement non atomique – utilisez plutôt :func:`Value` pour " +"vous assurer de synchroniser automatiquement avec un verrou." #: library/multiprocessing.rst:1505 msgid "" -"Note that an array of :data:`ctypes.c_char` has ``value`` and ``raw`` " -"attributes which allow one to use it to store and retrieve strings -- see " -"documentation for :mod:`ctypes`." +"Note that an array of :data:`ctypes.c_char` has ``value`` and ``raw`` attributes which allow one to use it to " +"store and retrieve strings -- see documentation for :mod:`ctypes`." msgstr "" -"Notez qu'un tableau de :data:`ctypes.c_char` a ses attributs *value* et " -"*raw* qui permettent de l'utiliser pour stocker et récupérer des chaînes de " -"caractères – voir la documentation de :mod:`ctypes`." +"Notez qu'un tableau de :data:`ctypes.c_char` a ses attributs *value* et *raw* qui permettent de l'utiliser pour " +"stocker et récupérer des chaînes de caractères – voir la documentation de :mod:`ctypes`." #: library/multiprocessing.rst:1511 msgid "" -"The same as :func:`RawArray` except that depending on the value of *lock* a " -"process-safe synchronization wrapper may be returned instead of a raw ctypes " -"array." +"The same as :func:`RawArray` except that depending on the value of *lock* a process-safe synchronization wrapper " +"may be returned instead of a raw ctypes array." msgstr "" -"Identique à :func:`RawArray` à l'exception que suivant la valeur de *lock* " -"un *wrapper* de synchronisation *process-safe* pourra être renvoyé à la " -"place d'un tableau *ctypes* brut." +"Identique à :func:`RawArray` à l'exception que suivant la valeur de *lock* un *wrapper* de synchronisation " +"*process-safe* pourra être renvoyé à la place d'un tableau *ctypes* brut." #: library/multiprocessing.rst:1515 library/multiprocessing.rst:1531 msgid "" -"If *lock* is ``True`` (the default) then a new lock object is created to " -"synchronize access to the value. If *lock* is a :class:`~multiprocessing." -"Lock` or :class:`~multiprocessing.RLock` object then that will be used to " -"synchronize access to the value. If *lock* is ``False`` then access to the " -"returned object will not be automatically protected by a lock, so it will " -"not necessarily be \"process-safe\"." +"If *lock* is ``True`` (the default) then a new lock object is created to synchronize access to the value. If " +"*lock* is a :class:`~multiprocessing.Lock` or :class:`~multiprocessing.RLock` object then that will be used to " +"synchronize access to the value. If *lock* is ``False`` then access to the returned object will not be " +"automatically protected by a lock, so it will not necessarily be \"process-safe\"." msgstr "" -"Si *lock* vaut ``True`` (par défaut), alors un nouveau verrou est créé pour " -"synchroniser l'accès à la valeur. Si *lock* est un objet :class:" -"`~multiprocessing.Lock` ou :class:`~multiprocessing.RLock` alors il sera " -"utilisé pour synchroniser l'accès à la valeur. Si *lock* vaut ``False``, " -"l'accès à l'objet renvoyé ne sera pas automatiquement protégé par un verrou, " -"donc il ne sera pas forcément « *process-safe* »." +"Si *lock* vaut ``True`` (par défaut), alors un nouveau verrou est créé pour synchroniser l'accès à la valeur. Si " +"*lock* est un objet :class:`~multiprocessing.Lock` ou :class:`~multiprocessing.RLock` alors il sera utilisé pour " +"synchroniser l'accès à la valeur. Si *lock* vaut ``False``, l'accès à l'objet renvoyé ne sera pas automatiquement " +"protégé par un verrou, donc il ne sera pas forcément « *process-safe* »." #: library/multiprocessing.rst:1527 msgid "" -"The same as :func:`RawValue` except that depending on the value of *lock* a " -"process-safe synchronization wrapper may be returned instead of a raw ctypes " -"object." +"The same as :func:`RawValue` except that depending on the value of *lock* a process-safe synchronization wrapper " +"may be returned instead of a raw ctypes object." msgstr "" -"Identique à :func:`RawValue` à l'exception que suivant la valeur de *lock* " -"un *wrapper* de synchronisation *process-safe* pourra être renvoyé à la " -"place d'un objet *ctypes* brut." +"Identique à :func:`RawValue` à l'exception que suivant la valeur de *lock* un *wrapper* de synchronisation " +"*process-safe* pourra être renvoyé à la place d'un objet *ctypes* brut." #: library/multiprocessing.rst:1542 -msgid "" -"Return a ctypes object allocated from shared memory which is a copy of the " -"ctypes object *obj*." -msgstr "" -"Renvoie un objet *ctypes* alloué depuis la mémoire partagée, qui est une " -"copie de l'objet *ctypes* *obj*." +msgid "Return a ctypes object allocated from shared memory which is a copy of the ctypes object *obj*." +msgstr "Renvoie un objet *ctypes* alloué depuis la mémoire partagée, qui est une copie de l'objet *ctypes* *obj*." #: library/multiprocessing.rst:1547 msgid "" -"Return a process-safe wrapper object for a ctypes object which uses *lock* " -"to synchronize access. If *lock* is ``None`` (the default) then a :class:" -"`multiprocessing.RLock` object is created automatically." +"Return a process-safe wrapper object for a ctypes object which uses *lock* to synchronize access. If *lock* is " +"``None`` (the default) then a :class:`multiprocessing.RLock` object is created automatically." msgstr "" -"Renvoie un *wrapper* *process-safe* autour de l'objet *ctypes* qui utilise " -"*lock* pour synchroniser l'accès. Si *lock* est ``None`` (par défaut), un " -"objet :class:`multiprocessing.RLock` est créé automatiquement." +"Renvoie un *wrapper* *process-safe* autour de l'objet *ctypes* qui utilise *lock* pour synchroniser l'accès. Si " +"*lock* est ``None`` (par défaut), un objet :class:`multiprocessing.RLock` est créé automatiquement." #: library/multiprocessing.rst:1551 msgid "" -"A synchronized wrapper will have two methods in addition to those of the " -"object it wraps: :meth:`get_obj` returns the wrapped object and :meth:" -"`get_lock` returns the lock object used for synchronization." +"A synchronized wrapper will have two methods in addition to those of the object it wraps: :meth:`get_obj` returns " +"the wrapped object and :meth:`get_lock` returns the lock object used for synchronization." msgstr "" -"Un *wrapper* synchronisé aura deux méthodes en plus de celles de l'objet " -"qu'il enveloppe : :meth:`get_obj` renvoie l'objet *wrappé* et :meth:" -"`get_lock` renvoie le verrou utilisé pour la synchronisation." +"Un *wrapper* synchronisé aura deux méthodes en plus de celles de l'objet qu'il enveloppe : :meth:`get_obj` " +"renvoie l'objet *wrappé* et :meth:`get_lock` renvoie le verrou utilisé pour la synchronisation." #: library/multiprocessing.rst:1555 msgid "" -"Note that accessing the ctypes object through the wrapper can be a lot " -"slower than accessing the raw ctypes object." +"Note that accessing the ctypes object through the wrapper can be a lot slower than accessing the raw ctypes " +"object." msgstr "" -"Notez qu'accéder à l'objet *ctypes* à travers le *wrapper* peut s'avérer " -"beaucoup plus lent qu'accéder directement à l'objet *ctypes* brut." +"Notez qu'accéder à l'objet *ctypes* à travers le *wrapper* peut s'avérer beaucoup plus lent qu'accéder " +"directement à l'objet *ctypes* brut." #: library/multiprocessing.rst:1558 msgid "Synchronized objects support the :term:`context manager` protocol." -msgstr "" -"Les objets synchronisés supportent le protocole :term:`context manager`." +msgstr "Les objets synchronisés supportent le protocole :term:`context manager`." #: library/multiprocessing.rst:1562 msgid "" -"The table below compares the syntax for creating shared ctypes objects from " -"shared memory with the normal ctypes syntax. (In the table ``MyStruct`` is " -"some subclass of :class:`ctypes.Structure`.)" +"The table below compares the syntax for creating shared ctypes objects from shared memory with the normal ctypes " +"syntax. (In the table ``MyStruct`` is some subclass of :class:`ctypes.Structure`.)" msgstr "" -"Le tableau ci-dessous compare la syntaxe de création des objets *ctypes* " -"partagés depuis une mémoire partagée avec la syntaxe normale *ctypes*. (Dans " -"le tableau, ``MyStruct`` est une sous-classe quelconque de :class:`ctypes." +"Le tableau ci-dessous compare la syntaxe de création des objets *ctypes* partagés depuis une mémoire partagée " +"avec la syntaxe normale *ctypes*. (Dans le tableau, ``MyStruct`` est une sous-classe quelconque de :class:`ctypes." "Structure`.)" #: library/multiprocessing.rst:1567 @@ -2498,12 +2053,8 @@ msgid "RawArray('i', (9, 2, 8))" msgstr "RawArray('i', (9, 2, 8))" #: library/multiprocessing.rst:1576 -msgid "" -"Below is an example where a number of ctypes objects are modified by a child " -"process::" -msgstr "" -"Ci-dessous un exemple où des objets *ctypes* sont modifiés par un processus " -"fils ::" +msgid "Below is an example where a number of ctypes objects are modified by a child process::" +msgstr "Ci-dessous un exemple où des objets *ctypes* sont modifiés par un processus fils ::" #: library/multiprocessing.rst:1614 msgid "The results printed are ::" @@ -2515,41 +2066,33 @@ msgstr "Gestionnaires" #: library/multiprocessing.rst:1629 msgid "" -"Managers provide a way to create data which can be shared between different " -"processes, including sharing over a network between processes running on " -"different machines. A manager object controls a server process which manages " -"*shared objects*. Other processes can access the shared objects by using " -"proxies." +"Managers provide a way to create data which can be shared between different processes, including sharing over a " +"network between processes running on different machines. A manager object controls a server process which manages " +"*shared objects*. Other processes can access the shared objects by using proxies." msgstr "" -"Les gestionnaires fournissent un moyen de créer des données qui peuvent être " -"partagées entre les différents processus, incluant le partage à travers le " -"réseau entre des processus tournant sur des machines différentes. Un objet " -"gestionnaire contrôle un processus serveur qui gère les *shared objects*. " -"Les autres processus peuvent accéder aux objets partagés à l'aide de " -"mandataires." +"Les gestionnaires fournissent un moyen de créer des données qui peuvent être partagées entre les différents " +"processus, incluant le partage à travers le réseau entre des processus tournant sur des machines différentes. Un " +"objet gestionnaire contrôle un processus serveur qui gère les *shared objects*. Les autres processus peuvent " +"accéder aux objets partagés à l'aide de mandataires." #: library/multiprocessing.rst:1637 msgid "" -"Returns a started :class:`~multiprocessing.managers.SyncManager` object " -"which can be used for sharing objects between processes. The returned " -"manager object corresponds to a spawned child process and has methods which " -"will create shared objects and return corresponding proxies." +"Returns a started :class:`~multiprocessing.managers.SyncManager` object which can be used for sharing objects " +"between processes. The returned manager object corresponds to a spawned child process and has methods which will " +"create shared objects and return corresponding proxies." msgstr "" -"Renvoie un objet :class:`~multiprocessing.managers.SyncManager` démarré qui " -"peut être utilisé pour partager des objets entre les processus. L'objet " -"gestionnaire renvoyé correspond à un processus enfant instancié et possède " -"des méthodes pour créer des objets partagés et renvoyer les mandataires " -"correspondants." +"Renvoie un objet :class:`~multiprocessing.managers.SyncManager` démarré qui peut être utilisé pour partager des " +"objets entre les processus. L'objet gestionnaire renvoyé correspond à un processus enfant instancié et possède " +"des méthodes pour créer des objets partagés et renvoyer les mandataires correspondants." #: library/multiprocessing.rst:1645 msgid "" -"Manager processes will be shutdown as soon as they are garbage collected or " -"their parent process exits. The manager classes are defined in the :mod:" -"`multiprocessing.managers` module:" +"Manager processes will be shutdown as soon as they are garbage collected or their parent process exits. The " +"manager classes are defined in the :mod:`multiprocessing.managers` module:" msgstr "" -"Les processus gestionnaires seront arrêtés dès qu'ils seront collectés par " -"le ramasse-miettes ou que leur processus parent se terminera. Les classes " -"gestionnaires sont définies dans le module :mod:`multiprocessing.managers` :" +"Les processus gestionnaires seront arrêtés dès qu'ils seront collectés par le ramasse-miettes ou que leur " +"processus parent se terminera. Les classes gestionnaires sont définies dans le module :mod:`multiprocessing." +"managers` :" #: library/multiprocessing.rst:1651 msgid "Create a BaseManager object." @@ -2557,53 +2100,45 @@ msgstr "Crée un objet *BaseManager*." #: library/multiprocessing.rst:1653 msgid "" -"Once created one should call :meth:`start` or ``get_server()." -"serve_forever()`` to ensure that the manager object refers to a started " -"manager process." +"Once created one should call :meth:`start` or ``get_server().serve_forever()`` to ensure that the manager object " +"refers to a started manager process." msgstr "" -"Une fois créé il faut appeler :meth:`start` ou ``get_server()." -"serve_forever()`` pour assurer que l'objet gestionnaire référence un " -"processus gestionnaire démarré." +"Une fois créé il faut appeler :meth:`start` ou ``get_server().serve_forever()`` pour assurer que l'objet " +"gestionnaire référence un processus gestionnaire démarré." #: library/multiprocessing.rst:1656 msgid "" -"*address* is the address on which the manager process listens for new " -"connections. If *address* is ``None`` then an arbitrary one is chosen." +"*address* is the address on which the manager process listens for new connections. If *address* is ``None`` then " +"an arbitrary one is chosen." msgstr "" -"*address* est l'adresse sur laquelle le processus gestionnaire écoute pour " -"de nouvelles connexions. Si *address* est ``None``, une adresse arbitraire " -"est choisie." +"*address* est l'adresse sur laquelle le processus gestionnaire écoute pour de nouvelles connexions. Si *address* " +"est ``None``, une adresse arbitraire est choisie." #: library/multiprocessing.rst:1659 msgid "" -"*authkey* is the authentication key which will be used to check the validity " -"of incoming connections to the server process. If *authkey* is ``None`` " -"then ``current_process().authkey`` is used. Otherwise *authkey* is used and " -"it must be a byte string." +"*authkey* is the authentication key which will be used to check the validity of incoming connections to the " +"server process. If *authkey* is ``None`` then ``current_process().authkey`` is used. Otherwise *authkey* is used " +"and it must be a byte string." msgstr "" -"*authkey* est la clé d'authentification qui sera utilisée pour vérifier la " -"validité des connexions entrantes sur le processus serveur. Si *authkey* est " -"``None`` alors ``current_process().authkey`` est utilisée. Autrement " +"*authkey* est la clé d'authentification qui sera utilisée pour vérifier la validité des connexions entrantes sur " +"le processus serveur. Si *authkey* est ``None`` alors ``current_process().authkey`` est utilisée. Autrement " "*authkey* est utilisée et doit être une chaîne d'octets." #: library/multiprocessing.rst:1666 msgid "" -"Start a subprocess to start the manager. If *initializer* is not ``None`` " -"then the subprocess will call ``initializer(*initargs)`` when it starts." +"Start a subprocess to start the manager. If *initializer* is not ``None`` then the subprocess will call " +"``initializer(*initargs)`` when it starts." msgstr "" -"Démarre un sous-processus pour démarrer le gestionnaire. Si *initializer* " -"n'est pas ``None`` alors le sous-processus appellera " -"``initializer(*initargs)`` quand il démarrera." +"Démarre un sous-processus pour démarrer le gestionnaire. Si *initializer* n'est pas ``None`` alors le sous-" +"processus appellera ``initializer(*initargs)`` quand il démarrera." #: library/multiprocessing.rst:1671 msgid "" -"Returns a :class:`Server` object which represents the actual server under " -"the control of the Manager. The :class:`Server` object supports the :meth:" -"`serve_forever` method::" +"Returns a :class:`Server` object which represents the actual server under the control of the Manager. The :class:" +"`Server` object supports the :meth:`serve_forever` method::" msgstr "" -"Renvoie un objet :class:`Server` qui représente le serveur sous le contrôle " -"du gestionnaire. L'objet :class:`Server` supporte la méthode :meth:" -"`serve_forever` ::" +"Renvoie un objet :class:`Server` qui représente le serveur sous le contrôle du gestionnaire. L'objet :class:" +"`Server` supporte la méthode :meth:`serve_forever` ::" #: library/multiprocessing.rst:1680 msgid ":class:`Server` additionally has an :attr:`address` attribute." @@ -2611,113 +2146,91 @@ msgstr ":class:`Server` possède en plus un attribut :attr:`address`." #: library/multiprocessing.rst:1684 msgid "Connect a local manager object to a remote manager process::" -msgstr "" -"Connecte un objet gestionnaire local au processus gestionnaire distant ::" +msgstr "Connecte un objet gestionnaire local au processus gestionnaire distant ::" #: library/multiprocessing.rst:1692 msgid "" -"Stop the process used by the manager. This is only available if :meth:" -"`start` has been used to start the server process." +"Stop the process used by the manager. This is only available if :meth:`start` has been used to start the server " +"process." msgstr "" -"Stoppe le processus utilisé par le gestionnaire. Cela est disponible " -"uniquement si :meth:`start` a été utilisée pour démarrer le processus " -"serveur." +"Stoppe le processus utilisé par le gestionnaire. Cela est disponible uniquement si :meth:`start` a été utilisée " +"pour démarrer le processus serveur." #: library/multiprocessing.rst:1695 msgid "This can be called multiple times." msgstr "Cette méthode peut être appelée plusieurs fois." #: library/multiprocessing.rst:1699 -msgid "" -"A classmethod which can be used for registering a type or callable with the " -"manager class." +msgid "A classmethod which can be used for registering a type or callable with the manager class." msgstr "" -"Une méthode de classe qui peut être utilisée pour enregistrer un type ou un " -"appelable avec la classe gestionnaire." +"Une méthode de classe qui peut être utilisée pour enregistrer un type ou un appelable avec la classe gestionnaire." #: library/multiprocessing.rst:1702 msgid "" -"*typeid* is a \"type identifier\" which is used to identify a particular " -"type of shared object. This must be a string." +"*typeid* is a \"type identifier\" which is used to identify a particular type of shared object. This must be a " +"string." msgstr "" -"*typeif* est un « *type identifier* » qui est utilisé pour identifier un " -"type particulier d'objet partagé. Cela doit être une chaîne de caractères." +"*typeif* est un « *type identifier* » qui est utilisé pour identifier un type particulier d'objet partagé. Cela " +"doit être une chaîne de caractères." #: library/multiprocessing.rst:1705 msgid "" -"*callable* is a callable used for creating objects for this type " -"identifier. If a manager instance will be connected to the server using " -"the :meth:`connect` method, or if the *create_method* argument is ``False`` " -"then this can be left as ``None``." +"*callable* is a callable used for creating objects for this type identifier. If a manager instance will be " +"connected to the server using the :meth:`connect` method, or if the *create_method* argument is ``False`` then " +"this can be left as ``None``." msgstr "" -"*callable* est un objet appelable utilisé pour créer les objets avec cet " -"identifiant de type. Si une instance de gestionnaire prévoit de se connecter " -"au serveur en utilisant sa méthode :meth:`connect` ou si l'argument " -"*create_method* vaut ``False`` alors cet argument peut être laissé à " -"``None``." +"*callable* est un objet appelable utilisé pour créer les objets avec cet identifiant de type. Si une instance de " +"gestionnaire prévoit de se connecter au serveur en utilisant sa méthode :meth:`connect` ou si l'argument " +"*create_method* vaut ``False`` alors cet argument peut être laissé à ``None``." #: library/multiprocessing.rst:1711 msgid "" -"*proxytype* is a subclass of :class:`BaseProxy` which is used to create " -"proxies for shared objects with this *typeid*. If ``None`` then a proxy " -"class is created automatically." +"*proxytype* is a subclass of :class:`BaseProxy` which is used to create proxies for shared objects with this " +"*typeid*. If ``None`` then a proxy class is created automatically." msgstr "" -"*proxytype* est une sous-classe de :class:`BaseProxy` utilisée pour créer " -"des mandataires autour des objets partagés avec ce *typeid*. S'il est " -"``None``, une classe mandataire sera créée automatiquement." +"*proxytype* est une sous-classe de :class:`BaseProxy` utilisée pour créer des mandataires autour des objets " +"partagés avec ce *typeid*. S'il est ``None``, une classe mandataire sera créée automatiquement." #: library/multiprocessing.rst:1715 msgid "" -"*exposed* is used to specify a sequence of method names which proxies for " -"this typeid should be allowed to access using :meth:`BaseProxy." -"_callmethod`. (If *exposed* is ``None`` then :attr:`proxytype._exposed_` is " -"used instead if it exists.) In the case where no exposed list is specified, " -"all \"public methods\" of the shared object will be accessible. (Here a " -"\"public method\" means any attribute which has a :meth:`~object.__call__` " -"method and whose name does not begin with ``'_'``.)" -msgstr "" -"*exposed* est utilisé pour préciser une séquence de noms de méthodes dont " -"les mandataires pour ce *typeid* doivent être autorisés à accéder via :meth:" -"`BaseProxy._callmethod`. (Si *exposed* est ``None`` alors :attr:`proxytype." -"_exposed_` est utilisé à la place s'il existe.) Dans le cas où aucune liste " -"*exposed* n'est précisée, toutes les « méthodes publiques » de l'objet " -"partagé seront accessibles. (Ici une « méthode publique » signifie n'importe " -"quel attribut qui possède une méthode :meth:`~object.__call__` et dont le " -"nom ne commence pas par un ``'_'``.)" +"*exposed* is used to specify a sequence of method names which proxies for this typeid should be allowed to access " +"using :meth:`BaseProxy._callmethod`. (If *exposed* is ``None`` then :attr:`proxytype._exposed_` is used instead " +"if it exists.) In the case where no exposed list is specified, all \"public methods\" of the shared object will " +"be accessible. (Here a \"public method\" means any attribute which has a :meth:`~object.__call__` method and " +"whose name does not begin with ``'_'``.)" +msgstr "" +"*exposed* est utilisé pour préciser une séquence de noms de méthodes dont les mandataires pour ce *typeid* " +"doivent être autorisés à accéder via :meth:`BaseProxy._callmethod`. (Si *exposed* est ``None`` alors :attr:" +"`proxytype._exposed_` est utilisé à la place s'il existe.) Dans le cas où aucune liste *exposed* n'est précisée, " +"toutes les « méthodes publiques » de l'objet partagé seront accessibles. (Ici une « méthode publique » signifie " +"n'importe quel attribut qui possède une méthode :meth:`~object.__call__` et dont le nom ne commence pas par un " +"``'_'``.)" #: library/multiprocessing.rst:1724 msgid "" -"*method_to_typeid* is a mapping used to specify the return type of those " -"exposed methods which should return a proxy. It maps method names to typeid " -"strings. (If *method_to_typeid* is ``None`` then :attr:`proxytype." -"_method_to_typeid_` is used instead if it exists.) If a method's name is " -"not a key of this mapping or if the mapping is ``None`` then the object " -"returned by the method will be copied by value." -msgstr "" -"*method_to_typeid* est un tableau associatif utilisé pour préciser le type " -"de retour de ces méthodes exposées qui doivent renvoyer un mandataire. Il " -"associé un nom de méthode à une chaîne de caractères *typeid*. (Si " -"*method_to_typeid* est ``None``, :attr:`proxytype._method_to_typeid_` est " -"utilisé à la place s'il existe). Si le nom d'une méthode n'est pas une clé " -"de ce tableau associatif ou si la valeur associée est ``None``, l'objet " +"*method_to_typeid* is a mapping used to specify the return type of those exposed methods which should return a " +"proxy. It maps method names to typeid strings. (If *method_to_typeid* is ``None`` then :attr:`proxytype." +"_method_to_typeid_` is used instead if it exists.) If a method's name is not a key of this mapping or if the " +"mapping is ``None`` then the object returned by the method will be copied by value." +msgstr "" +"*method_to_typeid* est un tableau associatif utilisé pour préciser le type de retour de ces méthodes exposées qui " +"doivent renvoyer un mandataire. Il associé un nom de méthode à une chaîne de caractères *typeid*. (Si " +"*method_to_typeid* est ``None``, :attr:`proxytype._method_to_typeid_` est utilisé à la place s'il existe). Si le " +"nom d'une méthode n'est pas une clé de ce tableau associatif ou si la valeur associée est ``None``, l'objet " "renvoyé par la méthode sera une copie de la valeur." #: library/multiprocessing.rst:1731 msgid "" -"*create_method* determines whether a method should be created with name " -"*typeid* which can be used to tell the server process to create a new shared " -"object and return a proxy for it. By default it is ``True``." +"*create_method* determines whether a method should be created with name *typeid* which can be used to tell the " +"server process to create a new shared object and return a proxy for it. By default it is ``True``." msgstr "" -"*create_method* détermine si une méthode devrait être créée avec le nom " -"*typeid*, qui peut être utilisée pour indiquer au processus serveur de créer " -"un nouvel objet partagé et d'en renvoyer un mandataire. a valeur par défaut " -"est ``True``." +"*create_method* détermine si une méthode devrait être créée avec le nom *typeid*, qui peut être utilisée pour " +"indiquer au processus serveur de créer un nouvel objet partagé et d'en renvoyer un mandataire. a valeur par " +"défaut est ``True``." #: library/multiprocessing.rst:1735 msgid ":class:`BaseManager` instances also have one read-only property:" -msgstr "" -"Les instances de :class:`BaseManager` ont aussi une propriété en lecture " -"seule :" +msgstr "Les instances de :class:`BaseManager` ont aussi une propriété en lecture seule :" #: library/multiprocessing.rst:1739 msgid "The address used by the manager." @@ -2725,149 +2238,105 @@ msgstr "L'adresse utilisée par le gestionnaire." #: library/multiprocessing.rst:1741 msgid "" -"Manager objects support the context management protocol -- see :ref:" -"`typecontextmanager`. :meth:`~contextmanager.__enter__` starts the server " -"process (if it has not already started) and then returns the manager " -"object. :meth:`~contextmanager.__exit__` calls :meth:`shutdown`." +"Manager objects support the context management protocol -- see :ref:`typecontextmanager`. :meth:`~contextmanager." +"__enter__` starts the server process (if it has not already started) and then returns the manager object. :meth:" +"`~contextmanager.__exit__` calls :meth:`shutdown`." msgstr "" -"Les objets gestionnaires supportent le protocole des gestionnaires de " -"contexte – voir :ref:`typecontextmanager`. :meth:`~contextmanager.__enter__` " -"démarre le processus serveur (s'il n'a pas déjà été démarré) et renvoie " -"l'objet gestionnaire. :meth:`~contextmanager.__exit__` appelle :meth:" -"`shutdown`." +"Les objets gestionnaires supportent le protocole des gestionnaires de contexte – voir :ref:`typecontextmanager`. :" +"meth:`~contextmanager.__enter__` démarre le processus serveur (s'il n'a pas déjà été démarré) et renvoie l'objet " +"gestionnaire. :meth:`~contextmanager.__exit__` appelle :meth:`shutdown`." #: library/multiprocessing.rst:1747 msgid "" -"In previous versions :meth:`~contextmanager.__enter__` did not start the " -"manager's server process if it was not already started." +"In previous versions :meth:`~contextmanager.__enter__` did not start the manager's server process if it was not " +"already started." msgstr "" -"Dans les versions précédentes :meth:`~contextmanager.__enter__` ne démarrait " -"pas le processus serveur du gestionnaire s'il n'était pas déjà démarré." +"Dans les versions précédentes :meth:`~contextmanager.__enter__` ne démarrait pas le processus serveur du " +"gestionnaire s'il n'était pas déjà démarré." #: library/multiprocessing.rst:1752 msgid "" -"A subclass of :class:`BaseManager` which can be used for the synchronization " -"of processes. Objects of this type are returned by :func:`multiprocessing." -"Manager`." +"A subclass of :class:`BaseManager` which can be used for the synchronization of processes. Objects of this type " +"are returned by :func:`multiprocessing.Manager`." msgstr "" -"Une sous-classe de :class:`BaseManager` qui peut être utilisée pour la " -"synchronisation entre processus. Des objets de ce type sont renvoyés par :" -"func:`multiprocessing.Manager`." +"Une sous-classe de :class:`BaseManager` qui peut être utilisée pour la synchronisation entre processus. Des " +"objets de ce type sont renvoyés par :func:`multiprocessing.Manager`." #: library/multiprocessing.rst:1756 msgid "" -"Its methods create and return :ref:`multiprocessing-proxy_objects` for a " -"number of commonly used data types to be synchronized across processes. This " -"notably includes shared lists and dictionaries." +"Its methods create and return :ref:`multiprocessing-proxy_objects` for a number of commonly used data types to be " +"synchronized across processes. This notably includes shared lists and dictionaries." msgstr "" -"Ces méthodes créent et renvoient des :ref:`multiprocessing-proxy_objects` " -"pour un certain nombre de types de données communément utilisés pour être " -"synchronisés entre les processus. Elles incluent notamment des listes et " +"Ces méthodes créent et renvoient des :ref:`multiprocessing-proxy_objects` pour un certain nombre de types de " +"données communément utilisés pour être synchronisés entre les processus. Elles incluent notamment des listes et " "dictionnaires partagés." #: library/multiprocessing.rst:1762 -msgid "" -"Create a shared :class:`threading.Barrier` object and return a proxy for it." -msgstr "" -"Crée un objet :class:`threading.Barrier` partagé et renvoie un mandataire " -"pour cet objet." +msgid "Create a shared :class:`threading.Barrier` object and return a proxy for it." +msgstr "Crée un objet :class:`threading.Barrier` partagé et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1769 -msgid "" -"Create a shared :class:`threading.BoundedSemaphore` object and return a " -"proxy for it." -msgstr "" -"Crée un objet :class:`threading.BoundedSemaphore` partagé et renvoie un " -"mandataire pour cet objet." +msgid "Create a shared :class:`threading.BoundedSemaphore` object and return a proxy for it." +msgstr "Crée un objet :class:`threading.BoundedSemaphore` partagé et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1774 -msgid "" -"Create a shared :class:`threading.Condition` object and return a proxy for " -"it." -msgstr "" -"Crée un objet :class:`threading.Condition` partagé et renvoie un mandataire " -"pour cet objet." +msgid "Create a shared :class:`threading.Condition` object and return a proxy for it." +msgstr "Crée un objet :class:`threading.Condition` partagé et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1777 msgid "" -"If *lock* is supplied then it should be a proxy for a :class:`threading." -"Lock` or :class:`threading.RLock` object." +"If *lock* is supplied then it should be a proxy for a :class:`threading.Lock` or :class:`threading.RLock` object." msgstr "" -"Si *lock* est fourni alors il doit être un mandataire pour un objet :class:" -"`threading.Lock` ou :class:`threading.RLock`." +"Si *lock* est fourni alors il doit être un mandataire pour un objet :class:`threading.Lock` ou :class:`threading." +"RLock`." #: library/multiprocessing.rst:1785 -msgid "" -"Create a shared :class:`threading.Event` object and return a proxy for it." -msgstr "" -"Crée un objet :class:`threading.Event` partagé et renvoie un mandataire pour " -"cet objet." +msgid "Create a shared :class:`threading.Event` object and return a proxy for it." +msgstr "Crée un objet :class:`threading.Event` partagé et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1789 -msgid "" -"Create a shared :class:`threading.Lock` object and return a proxy for it." -msgstr "" -"Crée un objet :class:`threading.Lock` partagé et renvoie un mandataire pour " -"cet objet." +msgid "Create a shared :class:`threading.Lock` object and return a proxy for it." +msgstr "Crée un objet :class:`threading.Lock` partagé et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1793 msgid "Create a shared :class:`Namespace` object and return a proxy for it." -msgstr "" -"Crée un objet :class:`Namespace` partagé et renvoie un mandataire pour cet " -"objet." +msgstr "Crée un objet :class:`Namespace` partagé et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1797 msgid "Create a shared :class:`queue.Queue` object and return a proxy for it." -msgstr "" -"Crée un objet :class:`queue.Queue` partagé et renvoie un mandataire pour cet " -"objet." +msgstr "Crée un objet :class:`queue.Queue` partagé et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1801 -msgid "" -"Create a shared :class:`threading.RLock` object and return a proxy for it." -msgstr "" -"Crée un objet :class:`threading.RLock` partagé et renvoie un mandataire pour " -"cet objet." +msgid "Create a shared :class:`threading.RLock` object and return a proxy for it." +msgstr "Crée un objet :class:`threading.RLock` partagé et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1805 -msgid "" -"Create a shared :class:`threading.Semaphore` object and return a proxy for " -"it." -msgstr "" -"Crée un objet :class:`threading.Semaphore` partagé et renvoie un mandataire " -"pour cet objet." +msgid "Create a shared :class:`threading.Semaphore` object and return a proxy for it." +msgstr "Crée un objet :class:`threading.Semaphore` partagé et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1810 msgid "Create an array and return a proxy for it." msgstr "Crée un tableau et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1814 -msgid "" -"Create an object with a writable ``value`` attribute and return a proxy for " -"it." -msgstr "" -"Crée un objet avec un attribut ``value`` accessible en écriture et renvoie " -"un mandataire pour cet objet." +msgid "Create an object with a writable ``value`` attribute and return a proxy for it." +msgstr "Crée un objet avec un attribut ``value`` accessible en écriture et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1821 msgid "Create a shared :class:`dict` object and return a proxy for it." -msgstr "" -"Crée un objet :class:`dict` partagé et renvoie un mandataire pour cet objet." +msgstr "Crée un objet :class:`dict` partagé et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1826 msgid "Create a shared :class:`list` object and return a proxy for it." -msgstr "" -"Crée un objet :class:`list` partagé et renvoie un mandataire pour cet objet." +msgstr "Crée un objet :class:`list` partagé et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1828 msgid "" -"Shared objects are capable of being nested. For example, a shared container " -"object such as a shared list can contain other shared objects which will all " -"be managed and synchronized by the :class:`SyncManager`." +"Shared objects are capable of being nested. For example, a shared container object such as a shared list can " +"contain other shared objects which will all be managed and synchronized by the :class:`SyncManager`." msgstr "" -"Les objets partagés peuvent être imbriqués. Par exemple, un conteneur " -"partagé tel qu'une liste partagée peu contenir d'autres objets partagés qui " -"seront aussi gérés et synchronisés par le :class:`SyncManager`." +"Les objets partagés peuvent être imbriqués. Par exemple, un conteneur partagé tel qu'une liste partagée peu " +"contenir d'autres objets partagés qui seront aussi gérés et synchronisés par le :class:`SyncManager`." #: library/multiprocessing.rst:1835 msgid "A type that can register with :class:`SyncManager`." @@ -2875,21 +2344,19 @@ msgstr "Un type qui peut être enregistré avec :class:`SyncManager`." #: library/multiprocessing.rst:1837 msgid "" -"A namespace object has no public methods, but does have writable attributes. " -"Its representation shows the values of its attributes." +"A namespace object has no public methods, but does have writable attributes. Its representation shows the values " +"of its attributes." msgstr "" -"Un espace de nommage n'a pas de méthodes publiques, mais possède des " -"attributs accessibles en écriture. Sa représentation montre les valeurs de " -"ses attributs." +"Un espace de nommage n'a pas de méthodes publiques, mais possède des attributs accessibles en écriture. Sa " +"représentation montre les valeurs de ses attributs." #: library/multiprocessing.rst:1840 msgid "" -"However, when using a proxy for a namespace object, an attribute beginning " -"with ``'_'`` will be an attribute of the proxy and not an attribute of the " -"referent:" +"However, when using a proxy for a namespace object, an attribute beginning with ``'_'`` will be an attribute of " +"the proxy and not an attribute of the referent:" msgstr "" -"Cependant, en utilisant un mandataire pour un espace de nommage, un attribut " -"débutant par ``'_'`` est un attribut du mandataire et non de l'objet cible :" +"Cependant, en utilisant un mandataire pour un espace de nommage, un attribut débutant par ``'_'`` est un attribut " +"du mandataire et non de l'objet cible :" #: library/multiprocessing.rst:1856 msgid "Customized managers" @@ -2897,13 +2364,11 @@ msgstr "Gestionnaires personnalisés" #: library/multiprocessing.rst:1858 msgid "" -"To create one's own manager, one creates a subclass of :class:`BaseManager` " -"and uses the :meth:`~BaseManager.register` classmethod to register new types " -"or callables with the manager class. For example::" +"To create one's own manager, one creates a subclass of :class:`BaseManager` and uses the :meth:`~BaseManager." +"register` classmethod to register new types or callables with the manager class. For example::" msgstr "" -"Pour créer son propre gestionnaire, il faut créer une sous-classe de :class:" -"`BaseManager` et utiliser la méthode de classe :meth:`~BaseManager.register` " -"pour enregistrer de nouveaux types ou *callables* au gestionnaire. Par " +"Pour créer son propre gestionnaire, il faut créer une sous-classe de :class:`BaseManager` et utiliser la méthode " +"de classe :meth:`~BaseManager.register` pour enregistrer de nouveaux types ou *callables* au gestionnaire. Par " "exemple ::" #: library/multiprocessing.rst:1883 @@ -2912,20 +2377,17 @@ msgstr "Utiliser un gestionnaire distant" #: library/multiprocessing.rst:1885 msgid "" -"It is possible to run a manager server on one machine and have clients use " -"it from other machines (assuming that the firewalls involved allow it)." +"It is possible to run a manager server on one machine and have clients use it from other machines (assuming that " +"the firewalls involved allow it)." msgstr "" -"Il est possible de lancer un serveur gestionnaire sur une machine et d'avoir " -"des clients l'utilisant sur d'autres machines (en supposant que les pare-" -"feus impliqués l'autorisent)." +"Il est possible de lancer un serveur gestionnaire sur une machine et d'avoir des clients l'utilisant sur d'autres " +"machines (en supposant que les pare-feus impliqués l'autorisent)." #: library/multiprocessing.rst:1888 -msgid "" -"Running the following commands creates a server for a single shared queue " -"which remote clients can access::" +msgid "Running the following commands creates a server for a single shared queue which remote clients can access::" msgstr "" -"Exécuter les commandes suivantes crée un serveur pour une simple queue " -"partagée à laquelle des clients distants peuvent accéder ::" +"Exécuter les commandes suivantes crée un serveur pour une file simple partagée à laquelle des clients distants " +"peuvent accéder ::" #: library/multiprocessing.rst:1900 msgid "One client can access the server as follows::" @@ -2936,12 +2398,10 @@ msgid "Another client can also use it::" msgstr "Un autre client peut aussi l'utiliser ::" #: library/multiprocessing.rst:1921 -msgid "" -"Local processes can also access that queue, using the code from above on the " -"client to access it remotely::" +msgid "Local processes can also access that queue, using the code from above on the client to access it remotely::" msgstr "" -"Les processus locaux peuvent aussi accéder à cette queue, utilisant le code " -"précédent sur le client pour y accéder à distance ::" +"Les processus locaux peuvent aussi accéder à cette file, utilisant le code précédent sur le client pour y " +"accéder à distance ::" #: library/multiprocessing.rst:1946 msgid "Proxy Objects" @@ -2949,117 +2409,89 @@ msgstr "Objets mandataires" #: library/multiprocessing.rst:1948 msgid "" -"A proxy is an object which *refers* to a shared object which lives " -"(presumably) in a different process. The shared object is said to be the " -"*referent* of the proxy. Multiple proxy objects may have the same referent." +"A proxy is an object which *refers* to a shared object which lives (presumably) in a different process. The " +"shared object is said to be the *referent* of the proxy. Multiple proxy objects may have the same referent." msgstr "" -"Un mandataire est un objet qui *référence* un objet partagé appartenant " -"(supposément) à un processus différent. L'objet partagé est appelé le " -"*référent* du mandataire. Plusieurs mandataires peuvent avoir un même " -"référent." +"Un mandataire est un objet qui *référence* un objet partagé appartenant (supposément) à un processus différent. " +"L'objet partagé est appelé le *référent* du mandataire. Plusieurs mandataires peuvent avoir un même référent." #: library/multiprocessing.rst:1952 msgid "" -"A proxy object has methods which invoke corresponding methods of its " -"referent (although not every method of the referent will necessarily be " -"available through the proxy). In this way, a proxy can be used just like " -"its referent can:" +"A proxy object has methods which invoke corresponding methods of its referent (although not every method of the " +"referent will necessarily be available through the proxy). In this way, a proxy can be used just like its " +"referent can:" msgstr "" -"Un mandataire possède des méthodes qui appellent les méthodes " -"correspondantes du référent (bien que toutes les méthodes du référent ne " -"soient pas nécessairement accessibles à travers le mandataire). De cette " -"manière, un mandataire peut être utilisé comme le serait sont référent :" +"Un mandataire possède des méthodes qui appellent les méthodes correspondantes du référent (bien que toutes les " +"méthodes du référent ne soient pas nécessairement accessibles à travers le mandataire). De cette manière, un " +"mandataire peut être utilisé comme le serait sont référent :" #: library/multiprocessing.rst:1970 msgid "" -"Notice that applying :func:`str` to a proxy will return the representation " -"of the referent, whereas applying :func:`repr` will return the " -"representation of the proxy." +"Notice that applying :func:`str` to a proxy will return the representation of the referent, whereas applying :" +"func:`repr` will return the representation of the proxy." msgstr "" -"Notez qu'appliquer :func:`str` à un mandataire renvoie la représentation du " -"référent, alors que :func:`repr` renvoie celle du mandataire." +"Notez qu'appliquer :func:`str` à un mandataire renvoie la représentation du référent, alors que :func:`repr` " +"renvoie celle du mandataire." #: library/multiprocessing.rst:1974 msgid "" -"An important feature of proxy objects is that they are picklable so they can " -"be passed between processes. As such, a referent can contain :ref:" -"`multiprocessing-proxy_objects`. This permits nesting of these managed " -"lists, dicts, and other :ref:`multiprocessing-proxy_objects`:" +"An important feature of proxy objects is that they are picklable so they can be passed between processes. As " +"such, a referent can contain :ref:`multiprocessing-proxy_objects`. This permits nesting of these managed lists, " +"dicts, and other :ref:`multiprocessing-proxy_objects`:" msgstr "" -"Une fonctionnalité importantes des objets mandataires est qu'ils sont " -"sérialisables et peuvent donc être échangés entre les processus. Ainsi, un " -"référent peut contenir des :ref:`multiprocessing-proxy_objects`. Cela permet " -"d'imbriquer des listes et dictionnaires gérés ainsi que d'autres :ref:" -"`multiprocessing-proxy_objects` :" +"Une fonctionnalité importantes des objets mandataires est qu'ils sont sérialisables et peuvent donc être échangés " +"entre les processus. Ainsi, un référent peut contenir des :ref:`multiprocessing-proxy_objects`. Cela permet " +"d'imbriquer des listes et dictionnaires gérés ainsi que d'autres :ref:`multiprocessing-proxy_objects` :" #: library/multiprocessing.rst:1990 msgid "Similarly, dict and list proxies may be nested inside one another::" -msgstr "" -"De même, les mandataires de listes et dictionnaires peuvent être imbriqués " -"dans d'autres ::" +msgstr "De même, les mandataires de listes et dictionnaires peuvent être imbriqués dans d'autres ::" #: library/multiprocessing.rst:2003 msgid "" -"If standard (non-proxy) :class:`list` or :class:`dict` objects are contained " -"in a referent, modifications to those mutable values will not be propagated " -"through the manager because the proxy has no way of knowing when the values " -"contained within are modified. However, storing a value in a container " -"proxy (which triggers a ``__setitem__`` on the proxy object) does propagate " -"through the manager and so to effectively modify such an item, one could re-" -"assign the modified value to the container proxy::" -msgstr "" -"Si des objets standards (non *proxyfiés*) :class:`list` ou :class:`dict` " -"sont contenus dans un référent, les modifications sur ces valeurs mutables " -"ne seront pas propagées à travers le gestionnaire parce que le mandataire " -"n'a aucun moyen de savoir quand les valeurs contenues sont modifiées. " -"Cependant, stocker une valeur dans un conteneur mandataire (qui déclenche un " -"appel à ``__setitem__`` sur le mandataire) propage bien la modification à " -"travers le gestionnaire et modifie effectivement l'élément, il est ainsi " -"possible de réassigner la valeur modifiée au conteneur mandataire ::" +"If standard (non-proxy) :class:`list` or :class:`dict` objects are contained in a referent, modifications to " +"those mutable values will not be propagated through the manager because the proxy has no way of knowing when the " +"values contained within are modified. However, storing a value in a container proxy (which triggers a " +"``__setitem__`` on the proxy object) does propagate through the manager and so to effectively modify such an " +"item, one could re-assign the modified value to the container proxy::" +msgstr "" +"Si des objets standards (non *proxyfiés*) :class:`list` ou :class:`dict` sont contenus dans un référent, les " +"modifications sur ces valeurs mutables ne seront pas propagées à travers le gestionnaire parce que le mandataire " +"n'a aucun moyen de savoir quand les valeurs contenues sont modifiées. Cependant, stocker une valeur dans un " +"conteneur mandataire (qui déclenche un appel à ``__setitem__`` sur le mandataire) propage bien la modification à " +"travers le gestionnaire et modifie effectivement l'élément, il est ainsi possible de réassigner la valeur " +"modifiée au conteneur mandataire ::" #: library/multiprocessing.rst:2022 msgid "" -"This approach is perhaps less convenient than employing nested :ref:" -"`multiprocessing-proxy_objects` for most use cases but also demonstrates a " -"level of control over the synchronization." +"This approach is perhaps less convenient than employing nested :ref:`multiprocessing-proxy_objects` for most use " +"cases but also demonstrates a level of control over the synchronization." msgstr "" -"Cette approche est peut-être moins pratique que d'utiliser des :ref:" -"`multiprocessing-proxy_objects` imbriqués pour la majorité des cas " -"d'utilisation, mais démontre aussi un certain niveau de contrôle sur la " -"synchronisation." +"Cette approche est peut-être moins pratique que d'utiliser des :ref:`multiprocessing-proxy_objects` imbriqués " +"pour la majorité des cas d'utilisation, mais démontre aussi un certain niveau de contrôle sur la synchronisation." #: library/multiprocessing.rst:2028 msgid "" -"The proxy types in :mod:`multiprocessing` do nothing to support comparisons " -"by value. So, for instance, we have:" +"The proxy types in :mod:`multiprocessing` do nothing to support comparisons by value. So, for instance, we have:" msgstr "" -"Les types de mandataires de :mod:`multiprocessing` n'implémentent rien pour " -"la comparaison par valeurs. Par exemple, on a :" +"Les types de mandataires de :mod:`multiprocessing` n'implémentent rien pour la comparaison par valeurs. Par " +"exemple, on a :" #: library/multiprocessing.rst:2036 -msgid "" -"One should just use a copy of the referent instead when making comparisons." -msgstr "" -"Il faut à la place simplement utiliser une copie du référent pour faire les " -"comparaisons." +msgid "One should just use a copy of the referent instead when making comparisons." +msgstr "Il faut à la place simplement utiliser une copie du référent pour faire les comparaisons." #: library/multiprocessing.rst:2040 msgid "Proxy objects are instances of subclasses of :class:`BaseProxy`." -msgstr "" -"Les objets mandataires sont des instances de sous-classes de :class:" -"`BaseProxy`." +msgstr "Les objets mandataires sont des instances de sous-classes de :class:`BaseProxy`." #: library/multiprocessing.rst:2044 msgid "Call and return the result of a method of the proxy's referent." -msgstr "" -"Appelle et renvoie le résultat d'une méthode du référent du mandataire." +msgstr "Appelle et renvoie le résultat d'une méthode du référent du mandataire." #: library/multiprocessing.rst:2046 -msgid "" -"If ``proxy`` is a proxy whose referent is ``obj`` then the expression ::" -msgstr "" -"Si ``proxy`` est un mandataire sont le référent est ``obj``, alors " -"l'expression ::" +msgid "If ``proxy`` is a proxy whose referent is ``obj`` then the expression ::" +msgstr "Si ``proxy`` est un mandataire sont le référent est ``obj``, alors l'expression ::" #: library/multiprocessing.rst:2050 msgid "will evaluate the expression ::" @@ -3071,33 +2503,25 @@ msgstr "dans le processus du gestionnaire." #: library/multiprocessing.rst:2056 msgid "" -"The returned value will be a copy of the result of the call or a proxy to a " -"new shared object -- see documentation for the *method_to_typeid* argument " -"of :meth:`BaseManager.register`." +"The returned value will be a copy of the result of the call or a proxy to a new shared object -- see " +"documentation for the *method_to_typeid* argument of :meth:`BaseManager.register`." msgstr "" -"La valeur renvoyée sera une copie du résultat de l'appel ou un mandataire " -"sur un nouvel objet partagé – voir l'a documentation de l'argument " -"*method_to_typeid* de :meth:`BaseManager.register`." +"La valeur renvoyée sera une copie du résultat de l'appel ou un mandataire sur un nouvel objet partagé – voir l'a " +"documentation de l'argument *method_to_typeid* de :meth:`BaseManager.register`." #: library/multiprocessing.rst:2060 msgid "" -"If an exception is raised by the call, then is re-raised by :meth:" -"`_callmethod`. If some other exception is raised in the manager's process " -"then this is converted into a :exc:`RemoteError` exception and is raised by :" -"meth:`_callmethod`." +"If an exception is raised by the call, then is re-raised by :meth:`_callmethod`. If some other exception is " +"raised in the manager's process then this is converted into a :exc:`RemoteError` exception and is raised by :meth:" +"`_callmethod`." msgstr "" -"Si une exception est levée par l'appel, elle est relayée par :meth:" -"`_callmethod`. Si une autre exception est levée par le processus du " -"gestionnaire, elle est convertie en une :exc:`RemoteError` et est levée par :" -"meth:`_callmethod`." +"Si une exception est levée par l'appel, elle est relayée par :meth:`_callmethod`. Si une autre exception est " +"levée par le processus du gestionnaire, elle est convertie en une :exc:`RemoteError` et est levée par :meth:" +"`_callmethod`." #: library/multiprocessing.rst:2065 -msgid "" -"Note in particular that an exception will be raised if *methodname* has not " -"been *exposed*." -msgstr "" -"Notez en particulier qu'une exception est levée si *methodname* n'est pas " -"*exposée*." +msgid "Note in particular that an exception will be raised if *methodname* has not been *exposed*." +msgstr "Notez en particulier qu'une exception est levée si *methodname* n'est pas *exposée*." #: library/multiprocessing.rst:2068 msgid "An example of the usage of :meth:`_callmethod`:" @@ -3125,115 +2549,90 @@ msgstr "Nettoyage" #: library/multiprocessing.rst:2100 msgid "" -"A proxy object uses a weakref callback so that when it gets garbage " -"collected it deregisters itself from the manager which owns its referent." +"A proxy object uses a weakref callback so that when it gets garbage collected it deregisters itself from the " +"manager which owns its referent." msgstr "" -"Un mandataire utilise un *callback* sous une référence faible de façon à ce " -"que quand il est collecté par le ramasse-miettes, il se désenregistre auprès " -"du gestionnaire qui possède le référent." +"Un mandataire utilise un *callback* sous une référence faible de façon à ce que quand il est collecté par le " +"ramasse-miettes, il se désenregistre auprès du gestionnaire qui possède le référent." #: library/multiprocessing.rst:2103 -msgid "" -"A shared object gets deleted from the manager process when there are no " -"longer any proxies referring to it." -msgstr "" -"Un objet partagé est supprimé par le processus gestionnaire quand plus aucun " -"mandataire ne le référence." +msgid "A shared object gets deleted from the manager process when there are no longer any proxies referring to it." +msgstr "Un objet partagé est supprimé par le processus gestionnaire quand plus aucun mandataire ne le référence." #: library/multiprocessing.rst:2108 msgid "Process Pools" msgstr "Pools de processus" #: library/multiprocessing.rst:2113 -msgid "" -"One can create a pool of processes which will carry out tasks submitted to " -"it with the :class:`Pool` class." +msgid "One can create a pool of processes which will carry out tasks submitted to it with the :class:`Pool` class." msgstr "" -"On peut créer un pool de processus qui exécuteront les tâches qui lui seront " -"soumises avec la classe :class:`Pool`." +"On peut créer un pool de processus qui exécuteront les tâches qui lui seront soumises avec la classe :class:" +"`Pool`." #: library/multiprocessing.rst:2118 msgid "" -"A process pool object which controls a pool of worker processes to which " -"jobs can be submitted. It supports asynchronous results with timeouts and " -"callbacks and has a parallel map implementation." +"A process pool object which controls a pool of worker processes to which jobs can be submitted. It supports " +"asynchronous results with timeouts and callbacks and has a parallel map implementation." msgstr "" -"Un objet *process pool* qui contrôle un pool de processus *workers* auquel " -"sont soumises des tâches. Il supporte les résultats asynchrones avec des " -"*timeouts* et des *callbacks* et possède une implémentation parallèle de " +"Un objet *process pool* qui contrôle un pool de processus *workers* auquel sont soumises des tâches. Il supporte " +"les résultats asynchrones avec des *timeouts* et des *callbacks* et possède une implémentation parallèle de " "*map*." #: library/multiprocessing.rst:2122 msgid "" -"*processes* is the number of worker processes to use. If *processes* is " -"``None`` then the number returned by :func:`os.cpu_count` is used." +"*processes* is the number of worker processes to use. If *processes* is ``None`` then the number returned by :" +"func:`os.cpu_count` is used." msgstr "" -"*processes* est le nombre de processus *workers* à utiliser. Si *processes* " -"est ``None``, le nombre renvoyé par :func:`os.cpu_count` est utilisé." +"*processes* est le nombre de processus *workers* à utiliser. Si *processes* est ``None``, le nombre renvoyé par :" +"func:`os.cpu_count` est utilisé." #: library/multiprocessing.rst:2125 library/multiprocessing.rst:2684 msgid "" -"If *initializer* is not ``None`` then each worker process will call " -"``initializer(*initargs)`` when it starts." +"If *initializer* is not ``None`` then each worker process will call ``initializer(*initargs)`` when it starts." msgstr "" -"Si *initializer* n'est pas ``None``, chaque processus *worker* appellera " -"``initializer(*initargs)`` en démarrant." +"Si *initializer* n'est pas ``None``, chaque processus *worker* appellera ``initializer(*initargs)`` en démarrant." #: library/multiprocessing.rst:2128 msgid "" -"*maxtasksperchild* is the number of tasks a worker process can complete " -"before it will exit and be replaced with a fresh worker process, to enable " -"unused resources to be freed. The default *maxtasksperchild* is ``None``, " -"which means worker processes will live as long as the pool." +"*maxtasksperchild* is the number of tasks a worker process can complete before it will exit and be replaced with " +"a fresh worker process, to enable unused resources to be freed. The default *maxtasksperchild* is ``None``, which " +"means worker processes will live as long as the pool." msgstr "" -"*maxtasksperchild* est le nombre de tâches qu'un processus *worker* peut " -"accomplir avant de se fermer et d'être remplacé par un *worker* frais, pour " -"permettre aux ressources inutilisées d'être libérées. Par défaut " -"*maxtasksperchild* est ``None``, ce qui signifie que le *worker* vit aussi " -"longtemps que le pool." +"*maxtasksperchild* est le nombre de tâches qu'un processus *worker* peut accomplir avant de se fermer et d'être " +"remplacé par un *worker* frais, pour permettre aux ressources inutilisées d'être libérées. Par défaut " +"*maxtasksperchild* est ``None``, ce qui signifie que le *worker* vit aussi longtemps que le pool." #: library/multiprocessing.rst:2133 msgid "" -"*context* can be used to specify the context used for starting the worker " -"processes. Usually a pool is created using the function :func:" -"`multiprocessing.Pool` or the :meth:`Pool` method of a context object. In " -"both cases *context* is set appropriately." +"*context* can be used to specify the context used for starting the worker processes. Usually a pool is created " +"using the function :func:`multiprocessing.Pool` or the :meth:`Pool` method of a context object. In both cases " +"*context* is set appropriately." msgstr "" -"*context* peut être utilisé pour préciser le contexte utilisé pour démarrer " -"les processus *workers*. Habituellement un pool est créé à l'aide de la " -"fonction :func:`multiprocessing.Pool` ou de la méthode :meth:`Pool` d'un " -"objet de contexte. Dans les deux cas *context* est réglé de façon appropriée." +"*context* peut être utilisé pour préciser le contexte utilisé pour démarrer les processus *workers*. " +"Habituellement un pool est créé à l'aide de la fonction :func:`multiprocessing.Pool` ou de la méthode :meth:" +"`Pool` d'un objet de contexte. Dans les deux cas *context* est réglé de façon appropriée." #: library/multiprocessing.rst:2139 -msgid "" -"Note that the methods of the pool object should only be called by the " -"process which created the pool." -msgstr "" -"Notez que les méthodes de l'objet *pool* ne doivent être appelées que par le " -"processus qui l'a créé." +msgid "Note that the methods of the pool object should only be called by the process which created the pool." +msgstr "Notez que les méthodes de l'objet *pool* ne doivent être appelées que par le processus qui l'a créé." #: library/multiprocessing.rst:2143 msgid "" -":class:`multiprocessing.pool` objects have internal resources that need to " -"be properly managed (like any other resource) by using the pool as a context " -"manager or by calling :meth:`close` and :meth:`terminate` manually. Failure " -"to do this can lead to the process hanging on finalization." +":class:`multiprocessing.pool` objects have internal resources that need to be properly managed (like any other " +"resource) by using the pool as a context manager or by calling :meth:`close` and :meth:`terminate` manually. " +"Failure to do this can lead to the process hanging on finalization." msgstr "" -"Les objets :class:`multiprocessing.pool` ont des ressources internes qui " -"doivent être correctement gérées (comme toute autre ressource) en utilisant " -"le pool comme gestionnaire de contexte ou en appelant :meth:`close` et :meth:" -"`terminate` manuellement. Si cela n'est pas fait, le processus peut être " -"bloqué à la finalisation." +"Les objets :class:`multiprocessing.pool` ont des ressources internes qui doivent être correctement gérées (comme " +"toute autre ressource) en utilisant le pool comme gestionnaire de contexte ou en appelant :meth:`close` et :meth:" +"`terminate` manuellement. Si cela n'est pas fait, le processus peut être bloqué à la finalisation." #: library/multiprocessing.rst:2148 msgid "" -"Note that is **not correct** to rely on the garbage colletor to destroy the " -"pool as CPython does not assure that the finalizer of the pool will be " -"called (see :meth:`object.__del__` for more information)." +"Note that is **not correct** to rely on the garbage colletor to destroy the pool as CPython does not assure that " +"the finalizer of the pool will be called (see :meth:`object.__del__` for more information)." msgstr "" -"Notez qu'il n'est **pas correct** de compter sur le ramasse-miette pour " -"détruire le pool car CPython n'assure pas que le *finalizer* du pool sera " -"appelé (voir :meth:`object.__del__` pour plus d'informations)." +"Notez qu'il n'est **pas correct** de compter sur le ramasse-miette pour détruire le pool car CPython n'assure pas " +"que le *finalizer* du pool sera appelé (voir :meth:`object.__del__` pour plus d'informations)." #: library/multiprocessing.rst:2152 msgid "*maxtasksperchild*" @@ -3245,111 +2644,84 @@ msgstr "*context*" #: library/multiprocessing.rst:2160 msgid "" -"Worker processes within a :class:`Pool` typically live for the complete " -"duration of the Pool's work queue. A frequent pattern found in other systems " -"(such as Apache, mod_wsgi, etc) to free resources held by workers is to " -"allow a worker within a pool to complete only a set amount of work before " -"being exiting, being cleaned up and a new process spawned to replace the old " -"one. The *maxtasksperchild* argument to the :class:`Pool` exposes this " +"Worker processes within a :class:`Pool` typically live for the complete duration of the Pool's work queue. A " +"frequent pattern found in other systems (such as Apache, mod_wsgi, etc) to free resources held by workers is to " +"allow a worker within a pool to complete only a set amount of work before being exiting, being cleaned up and a " +"new process spawned to replace the old one. The *maxtasksperchild* argument to the :class:`Pool` exposes this " "ability to the end user." msgstr "" -"Les processus *workers* à l'intérieur d'une :class:`Pool` vivent par défaut " -"aussi longtemps que la queue de travail du pool. Un modèle fréquent chez " -"d'autres systèmes (tels qu'Apache, *mod_wsgi*, etc.) pour libérer les " -"ressources détenues par les *workers* est d'autoriser un *worker* dans le " -"pool à accomplir seulement une certaine charge de travail avant de se " -"fermer, se retrouvant nettoyé et remplacé par un nouvelle processus " -"fraîchement lancé. L'argument *maxtasksperchild* de :class:`Pool` expose " -"cette fonctionnalité à l'utilisateur final." +"Les processus *workers* à l'intérieur d'une :class:`Pool` vivent par défaut aussi longtemps que la file de " +"travail du pool. Un modèle fréquent chez d'autres systèmes (tels qu'Apache, *mod_wsgi*, etc.) pour libérer les " +"ressources détenues par les *workers* est d'autoriser un *worker* dans le pool à accomplir seulement une certaine " +"charge de travail avant de se fermer, se retrouvant nettoyé et remplacé par un nouveau processus fraîchement " +"lancé. L'argument *maxtasksperchild* de :class:`Pool` expose cette fonctionnalité à l'utilisateur final." #: library/multiprocessing.rst:2170 msgid "" -"Call *func* with arguments *args* and keyword arguments *kwds*. It blocks " -"until the result is ready. Given this blocks, :meth:`apply_async` is better " -"suited for performing work in parallel. Additionally, *func* is only " +"Call *func* with arguments *args* and keyword arguments *kwds*. It blocks until the result is ready. Given this " +"blocks, :meth:`apply_async` is better suited for performing work in parallel. Additionally, *func* is only " "executed in one of the workers of the pool." msgstr "" -"Appelle *func* avec les arguments *args* et les arguments nommés *kwds*. " -"Bloque jusqu'à ce que que le résultat soit prêt. En raison de ce blocage, :" -"meth:`apply_async` est préférable pour exécuter du travail en parallèle. De " +"Appelle *func* avec les arguments *args* et les arguments nommés *kwds*. Bloque jusqu'à ce que que le résultat " +"soit prêt. En raison de ce blocage, :meth:`apply_async` est préférable pour exécuter du travail en parallèle. De " "plus, *func* est exécutée sur un seul des *workers* du pool." #: library/multiprocessing.rst:2177 -msgid "" -"A variant of the :meth:`apply` method which returns a :class:" -"`~multiprocessing.pool.AsyncResult` object." -msgstr "" -"Une variante de la méthode :meth:`apply` qui renvoie un objet :class:" -"`~multiprocessing.pool.AsyncResult`." +msgid "A variant of the :meth:`apply` method which returns a :class:`~multiprocessing.pool.AsyncResult` object." +msgstr "Une variante de la méthode :meth:`apply` qui renvoie un objet :class:`~multiprocessing.pool.AsyncResult`." #: library/multiprocessing.rst:2180 library/multiprocessing.rst:2211 msgid "" -"If *callback* is specified then it should be a callable which accepts a " -"single argument. When the result becomes ready *callback* is applied to it, " -"that is unless the call failed, in which case the *error_callback* is " -"applied instead." +"If *callback* is specified then it should be a callable which accepts a single argument. When the result becomes " +"ready *callback* is applied to it, that is unless the call failed, in which case the *error_callback* is applied " +"instead." msgstr "" -"Si *callback* est précisé alors ce doit être un objet appelable qui accepte " -"un seul argument. Quand le résultat est prêt, *callback* est appelé avec ce " -"résultat, si l'appel n'échoue pas auquel cas *error_callback* est appelé à " -"la place." +"Si *callback* est précisé alors ce doit être un objet appelable qui accepte un seul argument. Quand le résultat " +"est prêt, *callback* est appelé avec ce résultat, si l'appel n'échoue pas auquel cas *error_callback* est appelé " +"à la place." #: library/multiprocessing.rst:2185 library/multiprocessing.rst:2216 msgid "" -"If *error_callback* is specified then it should be a callable which accepts " -"a single argument. If the target function fails, then the *error_callback* " -"is called with the exception instance." +"If *error_callback* is specified then it should be a callable which accepts a single argument. If the target " +"function fails, then the *error_callback* is called with the exception instance." msgstr "" -"Si *error_callback* est précisé alors ce doit être un objet appelable qui " -"accepte un seul argument. Si la fonction cible échoue, alors " -"*error_callback* est appelé avec l'instance de l'exception." +"Si *error_callback* est précisé alors ce doit être un objet appelable qui accepte un seul argument. Si la " +"fonction cible échoue, alors *error_callback* est appelé avec l'instance de l'exception." #: library/multiprocessing.rst:2189 library/multiprocessing.rst:2220 -msgid "" -"Callbacks should complete immediately since otherwise the thread which " -"handles the results will get blocked." +msgid "Callbacks should complete immediately since otherwise the thread which handles the results will get blocked." msgstr "" -"Les *callbacks* doivent se terminer immédiatement, autrement le fil " -"d'exécution qui gère les résultats se retrouverait bloqué." +"Les *callbacks* doivent se terminer immédiatement, autrement le fil d'exécution qui gère les résultats se " +"retrouverait bloqué." #: library/multiprocessing.rst:2194 msgid "" -"A parallel equivalent of the :func:`map` built-in function (it supports only " -"one *iterable* argument though, for multiple iterables see :meth:`starmap`). " -"It blocks until the result is ready." +"A parallel equivalent of the :func:`map` built-in function (it supports only one *iterable* argument though, for " +"multiple iterables see :meth:`starmap`). It blocks until the result is ready." msgstr "" -"Un équivalent parallèle de la fonction native :func:`map` (qui ne prend " -"qu'un seul argument *itérable* ; pour en passer plusieurs, référez-vous à :" -"meth:`starmap`). Elle bloque jusqu'à ce que le résultat soit prêt." +"Un équivalent parallèle de la fonction native :func:`map` (qui ne prend qu'un seul argument *itérable* ; pour en " +"passer plusieurs, référez-vous à :meth:`starmap`). Elle bloque jusqu'à ce que le résultat soit prêt." #: library/multiprocessing.rst:2198 msgid "" -"This method chops the iterable into a number of chunks which it submits to " -"the process pool as separate tasks. The (approximate) size of these chunks " -"can be specified by setting *chunksize* to a positive integer." +"This method chops the iterable into a number of chunks which it submits to the process pool as separate tasks. " +"The (approximate) size of these chunks can be specified by setting *chunksize* to a positive integer." msgstr "" -"La méthode découpe l'itérable en un nombre de morceaux qu'elle envoie au " -"pool de processus comme des tâches séparées. La taille (approximative) de " -"ces morceaux peut être précisée en passant à *chunksize* un entier positif." +"La méthode découpe l'itérable en un nombre de morceaux qu'elle envoie au pool de processus comme des tâches " +"séparées. La taille (approximative) de ces morceaux peut être précisée en passant à *chunksize* un entier positif." #: library/multiprocessing.rst:2202 msgid "" -"Note that it may cause high memory usage for very long iterables. Consider " -"using :meth:`imap` or :meth:`imap_unordered` with explicit *chunksize* " -"option for better efficiency." +"Note that it may cause high memory usage for very long iterables. Consider using :meth:`imap` or :meth:" +"`imap_unordered` with explicit *chunksize* option for better efficiency." msgstr "" -"Notez que cela peut entraîner une grosse consommation de mémoire pour les " -"itérables très longs. Envisagez d'utiliser :meth:`imap` ou :meth:" -"`imap_unordered` avec l'option *chunksize* explicite pour une meilleure " +"Notez que cela peut entraîner une grosse consommation de mémoire pour les itérables très longs. Envisagez " +"d'utiliser :meth:`imap` ou :meth:`imap_unordered` avec l'option *chunksize* explicite pour une meilleure " "efficacité." #: library/multiprocessing.rst:2208 -msgid "" -"A variant of the :meth:`.map` method which returns a :class:" -"`~multiprocessing.pool.AsyncResult` object." -msgstr "" -"Une variante de la méthode :meth:`.map` qui renvoie un objet :class:" -"`~multiprocessing.pool.AsyncResult." +msgid "A variant of the :meth:`.map` method which returns a :class:`~multiprocessing.pool.AsyncResult` object." +msgstr "Une variante de la méthode :meth:`.map` qui renvoie un objet :class:`~multiprocessing.pool.AsyncResult`." #: library/multiprocessing.rst:2225 msgid "A lazier version of :meth:`.map`." @@ -3357,124 +2729,101 @@ msgstr "Une version paresseuse de :meth:`map`." #: library/multiprocessing.rst:2227 msgid "" -"The *chunksize* argument is the same as the one used by the :meth:`.map` " -"method. For very long iterables using a large value for *chunksize* can " -"make the job complete **much** faster than using the default value of ``1``." +"The *chunksize* argument is the same as the one used by the :meth:`.map` method. For very long iterables using a " +"large value for *chunksize* can make the job complete **much** faster than using the default value of ``1``." msgstr "" -"L'argument *chunksize* est le même que celui utilisé par la méthode :meth:`." -"map`. Pour de très longs itérables, utiliser une grande valeur pour " -"*chunksize* peut faire s'exécuter la tâche **beaucoup** plus rapidement " -"qu'en utilisant la valeur par défaut de ``1``." +"L'argument *chunksize* est le même que celui utilisé par la méthode :meth:`.map`. Pour de très longs itérables, " +"utiliser une grande valeur pour *chunksize* peut faire s'exécuter la tâche **beaucoup** plus rapidement qu'en " +"utilisant la valeur par défaut de ``1``." #: library/multiprocessing.rst:2232 msgid "" -"Also if *chunksize* is ``1`` then the :meth:`!next` method of the iterator " -"returned by the :meth:`imap` method has an optional *timeout* parameter: " -"``next(timeout)`` will raise :exc:`multiprocessing.TimeoutError` if the " +"Also if *chunksize* is ``1`` then the :meth:`!next` method of the iterator returned by the :meth:`imap` method " +"has an optional *timeout* parameter: ``next(timeout)`` will raise :exc:`multiprocessing.TimeoutError` if the " "result cannot be returned within *timeout* seconds." msgstr "" -"Aussi, si *chucksize* vaut ``1`` alors la méthode :meth:`!next` de " -"l'itérateur renvoyé par :meth:`imap` prend un paramètre optionnel " -"*timeout* : ``next(timeout)`` lève une :exc:`multiprocessing.TimeoutError` " -"si le résultat ne peut pas être renvoyé avant *timeout* secondes." +"Aussi, si *chucksize* vaut ``1`` alors la méthode :meth:`!next` de l'itérateur renvoyé par :meth:`imap` prend un " +"paramètre optionnel *timeout* : ``next(timeout)`` lève une :exc:`multiprocessing.TimeoutError` si le résultat ne " +"peut pas être renvoyé avant *timeout* secondes." #: library/multiprocessing.rst:2239 msgid "" -"The same as :meth:`imap` except that the ordering of the results from the " -"returned iterator should be considered arbitrary. (Only when there is only " -"one worker process is the order guaranteed to be \"correct\".)" +"The same as :meth:`imap` except that the ordering of the results from the returned iterator should be considered " +"arbitrary. (Only when there is only one worker process is the order guaranteed to be \"correct\".)" msgstr "" -"Identique à :meth:`imap` si ce n'est que l'ordre des résultats de " -"l'itérateur renvoyé doit être considéré comme arbitraire. (L'ordre n'est " -"garanti que quand il n'y a qu'un *worker*.)" +"Identique à :meth:`imap` si ce n'est que l'ordre des résultats de l'itérateur renvoyé doit être considéré comme " +"arbitraire. (L'ordre n'est garanti que quand il n'y a qu'un *worker*.)" #: library/multiprocessing.rst:2245 msgid "" -"Like :meth:`map` except that the elements of the *iterable* are expected to " -"be iterables that are unpacked as arguments." +"Like :meth:`map` except that the elements of the *iterable* are expected to be iterables that are unpacked as " +"arguments." msgstr "" -"Semblable à :meth:`map` à l'exception que les éléments d'*iterable* doivent " -"être des itérables qui seront dépaquetés comme arguments pour la fonction." +"Semblable à :meth:`map` à l'exception que les éléments d'*iterable* doivent être des itérables qui seront " +"dépaquetés comme arguments pour la fonction." #: library/multiprocessing.rst:2248 -msgid "" -"Hence an *iterable* of ``[(1,2), (3, 4)]`` results in ``[func(1,2), " -"func(3,4)]``." -msgstr "" -"Par conséquent un *iterable* ``[(1,2), (3, 4)]`` donnera pour résultat " -"``[func(1,2), func(3,4)]``." +msgid "Hence an *iterable* of ``[(1,2), (3, 4)]`` results in ``[func(1,2), func(3,4)]``." +msgstr "Par conséquent un *iterable* ``[(1,2), (3, 4)]`` donnera pour résultat ``[func(1,2), func(3,4)]``." #: library/multiprocessing.rst:2255 msgid "" -"A combination of :meth:`starmap` and :meth:`map_async` that iterates over " -"*iterable* of iterables and calls *func* with the iterables unpacked. " -"Returns a result object." +"A combination of :meth:`starmap` and :meth:`map_async` that iterates over *iterable* of iterables and calls " +"*func* with the iterables unpacked. Returns a result object." msgstr "" -"Une combinaison de :meth:`starmap` et :meth:`map_async` qui itère sur " -"*iterable* (composé d'itérables) et appelle *func* pour chaque itérable " -"dépaqueté. Renvoie l'objet résultat." +"Une combinaison de :meth:`starmap` et :meth:`map_async` qui itère sur *iterable* (composé d'itérables) et appelle " +"*func* pour chaque itérable dépaqueté. Renvoie l'objet résultat." #: library/multiprocessing.rst:2263 msgid "" -"Prevents any more tasks from being submitted to the pool. Once all the " -"tasks have been completed the worker processes will exit." +"Prevents any more tasks from being submitted to the pool. Once all the tasks have been completed the worker " +"processes will exit." msgstr "" -"Empêche de nouvelles tâches d'être envoyées à la *pool*. Les processus " -"*workers* se terminent une fois que toutes les tâches ont été complétées." +"Empêche de nouvelles tâches d'être envoyées à la *pool*. Les processus *workers* se terminent une fois que toutes " +"les tâches ont été complétées." #: library/multiprocessing.rst:2268 msgid "" -"Stops the worker processes immediately without completing outstanding work. " -"When the pool object is garbage collected :meth:`terminate` will be called " -"immediately." +"Stops the worker processes immediately without completing outstanding work. When the pool object is garbage " +"collected :meth:`terminate` will be called immediately." msgstr "" -"Stoppe immédiatement les processus *workers* sans finaliser les travaux " -"courants. Quand l'objet *pool* est collecté par le ramasse-miettes, sa " -"méthode :meth:`terminate` est appelée immédiatement." +"Stoppe immédiatement les processus *workers* sans finaliser les travaux courants. Quand l'objet *pool* est " +"collecté par le ramasse-miettes, sa méthode :meth:`terminate` est appelée immédiatement." #: library/multiprocessing.rst:2274 msgid "" -"Wait for the worker processes to exit. One must call :meth:`close` or :meth:" -"`terminate` before using :meth:`join`." +"Wait for the worker processes to exit. One must call :meth:`close` or :meth:`terminate` before using :meth:" +"`join`." msgstr "" -"Attend que les processus *workers* se terminent. Il est nécessaire " -"d'appeler :meth:`close` ou :meth:`terminate` avant d'utiliser :meth:`join`." +"Attend que les processus *workers* se terminent. Il est nécessaire d'appeler :meth:`close` ou :meth:`terminate` " +"avant d'utiliser :meth:`join`." #: library/multiprocessing.rst:2277 msgid "" -"Pool objects now support the context management protocol -- see :ref:" -"`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the pool " -"object, and :meth:`~contextmanager.__exit__` calls :meth:`terminate`." +"Pool objects now support the context management protocol -- see :ref:`typecontextmanager`. :meth:" +"`~contextmanager.__enter__` returns the pool object, and :meth:`~contextmanager.__exit__` calls :meth:`terminate`." msgstr "" -"Les pools de *workers* supportent maintenant le protocole des gestionnaires " -"de contexte – voir :ref:`typecontextmanager`. :meth:`~contextmanager." -"__enter__` renvoie l'objet *pool* et :meth:`~contextmanager.__exit__` " -"appelle :meth:`terminate`." +"Les pools de *workers* supportent maintenant le protocole des gestionnaires de contexte – voir :ref:" +"`typecontextmanager`. :meth:`~contextmanager.__enter__` renvoie l'objet *pool* et :meth:`~contextmanager." +"__exit__` appelle :meth:`terminate`." #: library/multiprocessing.rst:2285 -msgid "" -"The class of the result returned by :meth:`Pool.apply_async` and :meth:`Pool." -"map_async`." -msgstr "" -"La classe des résultats renvoyés par :meth:`Pool.apply_async` et :meth:`Pool." -"map_async`." +msgid "The class of the result returned by :meth:`Pool.apply_async` and :meth:`Pool.map_async`." +msgstr "La classe des résultats renvoyés par :meth:`Pool.apply_async` et :meth:`Pool.map_async`." #: library/multiprocessing.rst:2290 msgid "" -"Return the result when it arrives. If *timeout* is not ``None`` and the " -"result does not arrive within *timeout* seconds then :exc:`multiprocessing." -"TimeoutError` is raised. If the remote call raised an exception then that " +"Return the result when it arrives. If *timeout* is not ``None`` and the result does not arrive within *timeout* " +"seconds then :exc:`multiprocessing.TimeoutError` is raised. If the remote call raised an exception then that " "exception will be reraised by :meth:`get`." msgstr "" -"Renvoie le résultat quand il arrive. Si *timeout* n'est pas ``None`` et que " -"le résultat n'arrive pas avant *timeout* secondes, une :exc:`multiprocessing." -"TimeoutError` est levée. Si l'appel distance lève une exception, alors elle " -"est relayée par :meth:`get`." +"Renvoie le résultat quand il arrive. Si *timeout* n'est pas ``None`` et que le résultat n'arrive pas avant " +"*timeout* secondes, une :exc:`multiprocessing.TimeoutError` est levée. Si l'appel distance lève une exception, " +"alors elle est relayée par :meth:`get`." #: library/multiprocessing.rst:2297 msgid "Wait until the result is available or until *timeout* seconds pass." -msgstr "" -"Attend que le résultat soit disponible ou que *timeout* secondes s'écoulent." +msgstr "Attend que le résultat soit disponible ou que *timeout* secondes s'écoulent." #: library/multiprocessing.rst:2301 msgid "Return whether the call has completed." @@ -3482,24 +2831,20 @@ msgstr "Renvoie ``True`` ou ``False`` suivant si la tâche est accomplie." #: library/multiprocessing.rst:2305 msgid "" -"Return whether the call completed without raising an exception. Will raise :" -"exc:`ValueError` if the result is not ready." +"Return whether the call completed without raising an exception. Will raise :exc:`ValueError` if the result is " +"not ready." msgstr "" -"Renvoie ``True`` ou ``False`` suivant si la tâche est accomplie sans lever " -"d'exception. Lève une :exc:`ValueError` si le résultat n'est pas prêt." +"Renvoie ``True`` ou ``False`` suivant si la tâche est accomplie sans lever d'exception. Lève une :exc:" +"`ValueError` si le résultat n'est pas prêt." #: library/multiprocessing.rst:2308 -msgid "" -"If the result is not ready, :exc:`ValueError` is raised instead of :exc:" -"`AssertionError`." +msgid "If the result is not ready, :exc:`ValueError` is raised instead of :exc:`AssertionError`." msgstr "" -"Si le résultat n'est pas prêt, une :exc:`ValueError` est levée au lieu " -"d'une :exc:`AssertionError` auparavant." +"Si le résultat n'est pas prêt, une :exc:`ValueError` est levée au lieu d'une :exc:`AssertionError` auparavant." #: library/multiprocessing.rst:2312 msgid "The following example demonstrates the use of a pool::" -msgstr "" -"Les exemples suivants présentent l'utilisation d'un pool de *workers* ::" +msgstr "Les exemples suivants présentent l'utilisation d'un pool de *workers* ::" #: library/multiprocessing.rst:2339 msgid "Listeners and Clients" @@ -3507,276 +2852,206 @@ msgstr "Auditeurs et Clients" #: library/multiprocessing.rst:2344 msgid "" -"Usually message passing between processes is done using queues or by using :" -"class:`~Connection` objects returned by :func:`~multiprocessing.Pipe`." +"Usually message passing between processes is done using queues or by using :class:`~Connection` objects returned " +"by :func:`~multiprocessing.Pipe`." msgstr "" -"Habituellement l'échange de messages entre processus est réalisé en " -"utilisant des queues ou des objets :class:`~Connection` renvoyés par :func:" -"`~multiprocessing.Pipe`." +"Habituellement l'échange de messages entre processus est réalisé en utilisant des files ou des objets :class:" +"`~Connection` renvoyés par :func:`~multiprocessing.Pipe`." #: library/multiprocessing.rst:2348 msgid "" -"However, the :mod:`multiprocessing.connection` module allows some extra " -"flexibility. It basically gives a high level message oriented API for " -"dealing with sockets or Windows named pipes. It also has support for " -"*digest authentication* using the :mod:`hmac` module, and for polling " -"multiple connections at the same time." +"However, the :mod:`multiprocessing.connection` module allows some extra flexibility. It basically gives a high " +"level message oriented API for dealing with sockets or Windows named pipes. It also has support for *digest " +"authentication* using the :mod:`hmac` module, and for polling multiple connections at the same time." msgstr "" -"Cependant, le module :mod:`multiprocessing.connection` permet un peu plus de " -"flexibilité. Il fournit un message de plus haut-niveau orienté API pour " -"gérer des connecteurs ou des tubes nommés sous Windows. Il gère aussi " -"l'authentification par condensat (*digest authentication* en anglais) en " -"utilisant le module :mod:`hmac`, et pour interroger de multiples connexions " -"en même temps." +"Cependant, le module :mod:`multiprocessing.connection` permet un peu plus de flexibilité. Il fournit un message " +"de plus haut-niveau orienté API pour gérer des connecteurs ou des tubes nommés sous Windows. Il gère aussi " +"l'authentification par condensat (*digest authentication* en anglais) en utilisant le module :mod:`hmac`, et pour " +"interroger de multiples connexions en même temps." #: library/multiprocessing.rst:2357 -msgid "" -"Send a randomly generated message to the other end of the connection and " -"wait for a reply." -msgstr "" -"Envoie un message généré aléatoirement à l'autre bout de la connexion et " -"attend une réponse." +msgid "Send a randomly generated message to the other end of the connection and wait for a reply." +msgstr "Envoie un message généré aléatoirement à l'autre bout de la connexion et attend une réponse." #: library/multiprocessing.rst:2360 msgid "" -"If the reply matches the digest of the message using *authkey* as the key " -"then a welcome message is sent to the other end of the connection. " -"Otherwise :exc:`~multiprocessing.AuthenticationError` is raised." +"If the reply matches the digest of the message using *authkey* as the key then a welcome message is sent to the " +"other end of the connection. Otherwise :exc:`~multiprocessing.AuthenticationError` is raised." msgstr "" -"Si la réponse correspond au condensat du message avec la clé *authkey*, " -"alors un message de bienvenue est envoyé à l'autre bout de la connexion. " -"Autrement, une :exc:`~multiprocessing.AuthenticationError` est levée." +"Si la réponse correspond au condensat du message avec la clé *authkey*, alors un message de bienvenue est envoyé " +"à l'autre bout de la connexion. Autrement, une :exc:`~multiprocessing.AuthenticationError` est levée." #: library/multiprocessing.rst:2366 msgid "" -"Receive a message, calculate the digest of the message using *authkey* as " -"the key, and then send the digest back." +"Receive a message, calculate the digest of the message using *authkey* as the key, and then send the digest back." msgstr "" -"Reçoit un message, calcule le condensat du message en utilisant la clé " -"*authkey*, et envoie le condensat en réponse." +"Reçoit un message, calcule le condensat du message en utilisant la clé *authkey*, et envoie le condensat en " +"réponse." #: library/multiprocessing.rst:2369 -msgid "" -"If a welcome message is not received, then :exc:`~multiprocessing." -"AuthenticationError` is raised." -msgstr "" -"Si un message de bienvenue n'est pas reçu, une :exc:`~multiprocessing." -"AuthenticationError` est levée." +msgid "If a welcome message is not received, then :exc:`~multiprocessing.AuthenticationError` is raised." +msgstr "Si un message de bienvenue n'est pas reçu, une :exc:`~multiprocessing.AuthenticationError` est levée." #: library/multiprocessing.rst:2374 msgid "" -"Attempt to set up a connection to the listener which is using address " -"*address*, returning a :class:`~Connection`." +"Attempt to set up a connection to the listener which is using address *address*, returning a :class:`~Connection`." msgstr "" -"Essaie d'établir une connexion avec l'auditeur qui utilise l'adresse " -"*address*, renvoie une :class:`~Connection`." +"Essaie d'établir une connexion avec l'auditeur qui utilise l'adresse *address*, renvoie une :class:`~Connection`." #: library/multiprocessing.rst:2377 msgid "" -"The type of the connection is determined by *family* argument, but this can " -"generally be omitted since it can usually be inferred from the format of " -"*address*. (See :ref:`multiprocessing-address-formats`)" +"The type of the connection is determined by *family* argument, but this can generally be omitted since it can " +"usually be inferred from the format of *address*. (See :ref:`multiprocessing-address-formats`)" msgstr "" -"Le type de la connexion est déterminé par l'argument *family*, mais il peut " -"généralement être omis puisqu'il peut être inféré depuis le format " -"d'*address*. (Voir :ref:`multiprocessing-address-formats`)" +"Le type de la connexion est déterminé par l'argument *family*, mais il peut généralement être omis puisqu'il peut " +"être inféré depuis le format d'*address*. (Voir :ref:`multiprocessing-address-formats`)" #: library/multiprocessing.rst:2381 library/multiprocessing.rst:2416 msgid "" -"If *authkey* is given and not None, it should be a byte string and will be " -"used as the secret key for an HMAC-based authentication challenge. No " -"authentication is done if *authkey* is None. :exc:`~multiprocessing." -"AuthenticationError` is raised if authentication fails. See :ref:" -"`multiprocessing-auth-keys`." +"If *authkey* is given and not None, it should be a byte string and will be used as the secret key for an HMAC-" +"based authentication challenge. No authentication is done if *authkey* is None. :exc:`~multiprocessing." +"AuthenticationError` is raised if authentication fails. See :ref:`multiprocessing-auth-keys`." msgstr "" -"Si *authkey* est passée et n'est pas ``None``, elle doit être une chaîne " -"d'octets et sera utilisée comme clé secrète pour le défi d'authentification " -"basé sur HMAC. Aucune authentification n'est réalisée si *authkey* est " -"``None``. Une :exc:`~multiprocessing.AuthenticationError` est levée si " -"l'authentification échoue. Voir :ref:`multiprocessing-auth-keys`." +"Si *authkey* est passée et n'est pas ``None``, elle doit être une chaîne d'octets et sera utilisée comme clé " +"secrète pour le défi d'authentification basé sur HMAC. Aucune authentification n'est réalisée si *authkey* est " +"``None``. Une :exc:`~multiprocessing.AuthenticationError` est levée si l'authentification échoue. Voir :ref:" +"`multiprocessing-auth-keys`." #: library/multiprocessing.rst:2389 -msgid "" -"A wrapper for a bound socket or Windows named pipe which is 'listening' for " -"connections." -msgstr "" -"Une enveloppe autour d'un connecteur lié ou un tube nommé sous Windows qui " -"écoute pour des connexions." +msgid "A wrapper for a bound socket or Windows named pipe which is 'listening' for connections." +msgstr "Une enveloppe autour d'un connecteur lié ou un tube nommé sous Windows qui écoute pour des connexions." #: library/multiprocessing.rst:2392 -msgid "" -"*address* is the address to be used by the bound socket or named pipe of the " -"listener object." -msgstr "" -"*address* est l'adresse à utiliser par le connecteur lié ou le tube nommé de " -"l'objet auditeur." +msgid "*address* is the address to be used by the bound socket or named pipe of the listener object." +msgstr "*address* est l'adresse à utiliser par le connecteur lié ou le tube nommé de l'objet auditeur." #: library/multiprocessing.rst:2397 msgid "" -"If an address of '0.0.0.0' is used, the address will not be a connectable " -"end point on Windows. If you require a connectable end-point, you should use " -"'127.0.0.1'." +"If an address of '0.0.0.0' is used, the address will not be a connectable end point on Windows. If you require a " +"connectable end-point, you should use '127.0.0.1'." msgstr "" -"Si une adresse '0.0.0.0' est utilisée, l'adresse ne sera pas un point " -"d'accès connectable sous Windows. Si vous avez besoin d'un point d'accès " -"connectable, utilisez '127.0.0.1'." +"Si une adresse '0.0.0.0' est utilisée, l'adresse ne sera pas un point d'accès connectable sous Windows. Si vous " +"avez besoin d'un point d'accès connectable, utilisez '127.0.0.1'." #: library/multiprocessing.rst:2401 msgid "" -"*family* is the type of socket (or named pipe) to use. This can be one of " -"the strings ``'AF_INET'`` (for a TCP socket), ``'AF_UNIX'`` (for a Unix " -"domain socket) or ``'AF_PIPE'`` (for a Windows named pipe). Of these only " -"the first is guaranteed to be available. If *family* is ``None`` then the " -"family is inferred from the format of *address*. If *address* is also " -"``None`` then a default is chosen. This default is the family which is " -"assumed to be the fastest available. See :ref:`multiprocessing-address-" -"formats`. Note that if *family* is ``'AF_UNIX'`` and address is ``None`` " -"then the socket will be created in a private temporary directory created " -"using :func:`tempfile.mkstemp`." -msgstr "" -"*family* est le type de connecteur (ou tube nommé) à utiliser. Cela peut " -"être l'une des chaînes ``'AF_INET'`` (pour un connecteur TCP), ``'AF_UNIX'`` " -"(pour un connecteur Unix) ou ``'AF_PIPE'`` (pour un tube nommé sous " -"Windows). Seulement le premier d'entre eux est garanti d'être disponible. Si " -"*family* est ``None``, la famille est inférée depuis le format d'*address*. " -"Si *address* est aussi ``None``, la famille par défaut est utilisée. La " -"famille par défaut est supposée être la plus rapide disponible. Voir :ref:" -"`multiprocessing-address-formats`. Notez que si la *family* est " -"``'AF_UNIX'`` et qu'*address* est ``None``, le connecteur est créé dans un " +"*family* is the type of socket (or named pipe) to use. This can be one of the strings ``'AF_INET'`` (for a TCP " +"socket), ``'AF_UNIX'`` (for a Unix domain socket) or ``'AF_PIPE'`` (for a Windows named pipe). Of these only the " +"first is guaranteed to be available. If *family* is ``None`` then the family is inferred from the format of " +"*address*. If *address* is also ``None`` then a default is chosen. This default is the family which is assumed " +"to be the fastest available. See :ref:`multiprocessing-address-formats`. Note that if *family* is ``'AF_UNIX'`` " +"and address is ``None`` then the socket will be created in a private temporary directory created using :func:" +"`tempfile.mkstemp`." +msgstr "" +"*family* est le type de connecteur (ou tube nommé) à utiliser. Cela peut être l'une des chaînes ``'AF_INET'`` " +"(pour un connecteur TCP), ``'AF_UNIX'`` (pour un connecteur Unix) ou ``'AF_PIPE'`` (pour un tube nommé sous " +"Windows). Seulement le premier d'entre eux est garanti d'être disponible. Si *family* est ``None``, la famille " +"est inférée depuis le format d'*address*. Si *address* est aussi ``None``, la famille par défaut est utilisée. La " +"famille par défaut est supposée être la plus rapide disponible. Voir :ref:`multiprocessing-address-formats`. " +"Notez que si la *family* est ``'AF_UNIX'`` et qu'*address* est ``None``, le connecteur est créé dans un " "répertoire temporaire privé créé avec :func:`tempfile.mkstemp`." #: library/multiprocessing.rst:2412 msgid "" -"If the listener object uses a socket then *backlog* (1 by default) is passed " -"to the :meth:`~socket.socket.listen` method of the socket once it has been " -"bound." +"If the listener object uses a socket then *backlog* (1 by default) is passed to the :meth:`~socket.socket.listen` " +"method of the socket once it has been bound." msgstr "" -"Si l'objet auditeur utilise un connecteur alors *backlog* (1 par défaut) est " -"passé à la méthode :meth:`~socket.socket.listen` du connecteur une fois " -"qu'il a été lié." +"Si l'objet auditeur utilise un connecteur alors *backlog* (1 par défaut) est passé à la méthode :meth:`~socket." +"socket.listen` du connecteur une fois qu'il a été lié." #: library/multiprocessing.rst:2424 msgid "" -"Accept a connection on the bound socket or named pipe of the listener object " -"and return a :class:`~Connection` object. If authentication is attempted and " -"fails, then :exc:`~multiprocessing.AuthenticationError` is raised." +"Accept a connection on the bound socket or named pipe of the listener object and return a :class:`~Connection` " +"object. If authentication is attempted and fails, then :exc:`~multiprocessing.AuthenticationError` is raised." msgstr "" -"Accepte une connexion sur le connecteur lié ou le tube nommé de l'objet " -"auditeur et renvoie un objet :class:`~Connection`. Si la tentative " -"d'authentification échoue, une :exc:`~multiprocessing.AuthenticationError` " -"est levée." +"Accepte une connexion sur le connecteur lié ou le tube nommé de l'objet auditeur et renvoie un objet :class:" +"`~Connection`. Si la tentative d'authentification échoue, une :exc:`~multiprocessing.AuthenticationError` est " +"levée." #: library/multiprocessing.rst:2431 msgid "" -"Close the bound socket or named pipe of the listener object. This is called " -"automatically when the listener is garbage collected. However it is " -"advisable to call it explicitly." +"Close the bound socket or named pipe of the listener object. This is called automatically when the listener is " +"garbage collected. However it is advisable to call it explicitly." msgstr "" -"Ferme le connecteur lié ou le tube nommé de l'objet auditeur. La méthode est " -"appelée automatiquement quand l'auditeur est collecté par le ramasse-" -"miettes. Il est cependant conseillé de l'appeler explicitement." +"Ferme le connecteur lié ou le tube nommé de l'objet auditeur. La méthode est appelée automatiquement quand " +"l'auditeur est collecté par le ramasse-miettes. Il est cependant conseillé de l'appeler explicitement." #: library/multiprocessing.rst:2435 msgid "Listener objects have the following read-only properties:" -msgstr "" -"Les objets auditeurs ont aussi les propriétés en lecture seule suivantes :" +msgstr "Les objets auditeurs ont aussi les propriétés en lecture seule suivantes :" #: library/multiprocessing.rst:2439 msgid "The address which is being used by the Listener object." msgstr "L'adresse utilisée par l'objet auditeur." #: library/multiprocessing.rst:2443 -msgid "" -"The address from which the last accepted connection came. If this is " -"unavailable then it is ``None``." -msgstr "" -"L'adresse depuis laquelle a été établie la dernière connexion. ``None`` si " -"aucune n'est disponible." +msgid "The address from which the last accepted connection came. If this is unavailable then it is ``None``." +msgstr "L'adresse depuis laquelle a été établie la dernière connexion. ``None`` si aucune n'est disponible." #: library/multiprocessing.rst:2446 msgid "" -"Listener objects now support the context management protocol -- see :ref:" -"`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the " -"listener object, and :meth:`~contextmanager.__exit__` calls :meth:`close`." +"Listener objects now support the context management protocol -- see :ref:`typecontextmanager`. :meth:" +"`~contextmanager.__enter__` returns the listener object, and :meth:`~contextmanager.__exit__` calls :meth:`close`." msgstr "" -"Les objets auditeurs supportent maintenant le protocole des gestionnaires de " -"contexte – voir :ref:`typecontextmanager`. :meth:`~contextmanager.__enter__` " -"renvoie l'objet auditeur, et :meth:`~contextmanager.__exit__` appelle :meth:" -"`close`." +"Les objets auditeurs supportent maintenant le protocole des gestionnaires de contexte – voir :ref:" +"`typecontextmanager`. :meth:`~contextmanager.__enter__` renvoie l'objet auditeur, et :meth:`~contextmanager." +"__exit__` appelle :meth:`close`." #: library/multiprocessing.rst:2453 msgid "" -"Wait till an object in *object_list* is ready. Returns the list of those " -"objects in *object_list* which are ready. If *timeout* is a float then the " -"call blocks for at most that many seconds. If *timeout* is ``None`` then it " -"will block for an unlimited period. A negative timeout is equivalent to a " -"zero timeout." +"Wait till an object in *object_list* is ready. Returns the list of those objects in *object_list* which are " +"ready. If *timeout* is a float then the call blocks for at most that many seconds. If *timeout* is ``None`` " +"then it will block for an unlimited period. A negative timeout is equivalent to a zero timeout." msgstr "" -"Attend qu'un objet d'*object_list* soit prêt. Renvoie la liste de ces objets " -"d'*object_list* qui sont prêts. Si *timeout* est un nombre flottant, l'appel " -"bloquera au maximum ce nombre de secondes. Si *timeout* est ``None``, " -"l'appelle bloquera pour une durée non limitée. Un *timeout* négatif est " -"équivalent à un *timeout* nul." +"Attend qu'un objet d'*object_list* soit prêt. Renvoie la liste de ces objets d'*object_list* qui sont prêts. Si " +"*timeout* est un nombre flottant, l'appel bloquera au maximum ce nombre de secondes. Si *timeout* est ``None``, " +"l'appelle bloquera pour une durée non limitée. Un *timeout* négatif est équivalent à un *timeout* nul." #: library/multiprocessing.rst:2459 -msgid "" -"For both Unix and Windows, an object can appear in *object_list* if it is" -msgstr "" -"Pour Unix et Windows, un objet peut apparaître dans *object_list* s'il est" +msgid "For both Unix and Windows, an object can appear in *object_list* if it is" +msgstr "Pour Unix et Windows, un objet peut apparaître dans *object_list* s'il est" #: library/multiprocessing.rst:2462 msgid "a readable :class:`~multiprocessing.connection.Connection` object;" -msgstr "" -"un objet :class:`~multiprocessing.connection.Connection` accessible en " -"lecture ;" +msgstr "un objet :class:`~multiprocessing.connection.Connection` accessible en lecture ;" #: library/multiprocessing.rst:2463 msgid "a connected and readable :class:`socket.socket` object; or" msgstr "un objet :class:`socket.socket` connecté et accessible en lecture ; ou" #: library/multiprocessing.rst:2464 -msgid "" -"the :attr:`~multiprocessing.Process.sentinel` attribute of a :class:" -"`~multiprocessing.Process` object." -msgstr "" -"l'attribut :attr:`~multiprocessing.Process.sentinel` d'un objet :class:" -"`~multiprocessing.Process`." +msgid "the :attr:`~multiprocessing.Process.sentinel` attribute of a :class:`~multiprocessing.Process` object." +msgstr "l'attribut :attr:`~multiprocessing.Process.sentinel` d'un objet :class:`~multiprocessing.Process`." #: library/multiprocessing.rst:2467 msgid "" -"A connection or socket object is ready when there is data available to be " -"read from it, or the other end has been closed." +"A connection or socket object is ready when there is data available to be read from it, or the other end has been " +"closed." msgstr "" -"Une connexion (*socket* en anglais) est prête quand il y a des données " -"disponibles en lecture dessus, ou que l'autre bout a été fermé." +"Une connexion (*socket* en anglais) est prête quand il y a des données disponibles en lecture dessus, ou que " +"l'autre bout a été fermé." #: library/multiprocessing.rst:2470 msgid "" -"**Unix**: ``wait(object_list, timeout)`` almost equivalent ``select." -"select(object_list, [], [], timeout)``. The difference is that, if :func:" -"`select.select` is interrupted by a signal, it can raise :exc:`OSError` with " -"an error number of ``EINTR``, whereas :func:`wait` will not." +"**Unix**: ``wait(object_list, timeout)`` almost equivalent ``select.select(object_list, [], [], timeout)``. The " +"difference is that, if :func:`select.select` is interrupted by a signal, it can raise :exc:`OSError` with an " +"error number of ``EINTR``, whereas :func:`wait` will not." msgstr "" -"**Unix**: ``wait(object_list, timeout)`` est en grande partie équivalente à " -"``select.select(object_list, [], [], timeout)``. La différence est que, si :" -"func:`select.select` est interrompue par un signal, elle peut lever une :exc:" -"`OSError` avec un numéro d'erreur ``EINTR``, alors que :func:`wait` ne le " -"fera pas." +"**Unix**: ``wait(object_list, timeout)`` est en grande partie équivalente à ``select.select(object_list, [], [], " +"timeout)``. La différence est que, si :func:`select.select` est interrompue par un signal, elle peut lever une :" +"exc:`OSError` avec un numéro d'erreur ``EINTR``, alors que :func:`wait` ne le fera pas." #: library/multiprocessing.rst:2476 msgid "" -"**Windows**: An item in *object_list* must either be an integer handle which " -"is waitable (according to the definition used by the documentation of the " -"Win32 function ``WaitForMultipleObjects()``) or it can be an object with a :" -"meth:`fileno` method which returns a socket handle or pipe handle. (Note " -"that pipe handles and socket handles are **not** waitable handles.)" +"**Windows**: An item in *object_list* must either be an integer handle which is waitable (according to the " +"definition used by the documentation of the Win32 function ``WaitForMultipleObjects()``) or it can be an object " +"with a :meth:`fileno` method which returns a socket handle or pipe handle. (Note that pipe handles and socket " +"handles are **not** waitable handles.)" msgstr "" -"**Windows** : un élément d'*object_list* doit être soit un identifiant " -"*waitable* (en accord avec la définition utilisée par la documentation de la " -"fonction Win32 ``WaitForMultipleObjects()``), soit un objet avec une " -"méthode :meth:`fileno` qui renvoie un identifiant de connecteur ou de tube " -"(notez que les identifiants de tubes et de connecteurs **ne sont pas** des " -"identifiants *waitables*)." +"**Windows** : un élément d'*object_list* doit être soit un identifiant *waitable* (en accord avec la définition " +"utilisée par la documentation de la fonction Win32 ``WaitForMultipleObjects()``), soit un objet avec une méthode :" +"meth:`fileno` qui renvoie un identifiant de connecteur ou de tube (notez que les identifiants de tubes et de " +"connecteurs **ne sont pas** des identifiants *waitables*)." #: library/multiprocessing.rst:2486 msgid "**Examples**" @@ -3784,27 +3059,23 @@ msgstr "**Exemples**" #: library/multiprocessing.rst:2488 msgid "" -"The following server code creates a listener which uses ``'secret " -"password'`` as an authentication key. It then waits for a connection and " -"sends some data to the client::" +"The following server code creates a listener which uses ``'secret password'`` as an authentication key. It then " +"waits for a connection and sends some data to the client::" msgstr "" -"Le code serveur suivant crée un auditeur qui utilise ``'secret password'`` " -"comme clé d'authentification. Il attend ensuite une connexion et envoie les " -"données au client ::" +"Le code serveur suivant crée un auditeur qui utilise ``'secret password'`` comme clé d'authentification. Il " +"attend ensuite une connexion et envoie les données au client ::" #: library/multiprocessing.rst:2507 -msgid "" -"The following code connects to the server and receives some data from the " -"server::" +msgid "The following code connects to the server and receives some data from the server::" msgstr "Le code suivant se connecte au serveur et en reçoit des données ::" #: library/multiprocessing.rst:2524 msgid "" -"The following code uses :func:`~multiprocessing.connection.wait` to wait for " -"messages from multiple processes at once::" +"The following code uses :func:`~multiprocessing.connection.wait` to wait for messages from multiple processes at " +"once::" msgstr "" -"Le code suivant utilise :func:`~multiprocessing.connection.wait` pour " -"attendre des messages depuis plusieurs processus à la fois ::" +"Le code suivant utilise :func:`~multiprocessing.connection.wait` pour attendre des messages depuis plusieurs " +"processus à la fois ::" #: library/multiprocessing.rst:2563 msgid "Address Formats" @@ -3812,41 +3083,33 @@ msgstr "Formats d'adresses" #: library/multiprocessing.rst:2565 msgid "" -"An ``'AF_INET'`` address is a tuple of the form ``(hostname, port)`` where " -"*hostname* is a string and *port* is an integer." +"An ``'AF_INET'`` address is a tuple of the form ``(hostname, port)`` where *hostname* is a string and *port* is " +"an integer." msgstr "" -"Une adresse ``'AF_INET'`` est une paire de la forme ``(hostname, port)`` où " -"*hostname* est une chaîne et *port* un entier." +"Une adresse ``'AF_INET'`` est une paire de la forme ``(hostname, port)`` où *hostname* est une chaîne et *port* " +"un entier." #: library/multiprocessing.rst:2568 -msgid "" -"An ``'AF_UNIX'`` address is a string representing a filename on the " -"filesystem." -msgstr "" -"Une adresse ``'AF_UNIX'`` est une chaîne représentant un nom de fichier sur " -"le système de fichiers." +msgid "An ``'AF_UNIX'`` address is a string representing a filename on the filesystem." +msgstr "Une adresse ``'AF_UNIX'`` est une chaîne représentant un nom de fichier sur le système de fichiers." #: library/multiprocessing.rst:2571 msgid "" -"An ``'AF_PIPE'`` address is a string of the form :samp:`r'\\\\\\\\.\\\\pipe\\" -"\\{PipeName}'`. To use :func:`Client` to connect to a named pipe on a " -"remote computer called *ServerName* one should use an address of the form :" -"samp:`r'\\\\\\\\{ServerName}\\\\pipe\\\\{PipeName}'` instead." +"An ``'AF_PIPE'`` address is a string of the form :samp:`r'\\\\\\\\.\\\\pipe\\\\{PipeName}'`. To use :func:" +"`Client` to connect to a named pipe on a remote computer called *ServerName* one should use an address of the " +"form :samp:`r'\\\\\\\\{ServerName}\\\\pipe\\\\{PipeName}'` instead." msgstr "" -"Une adresse ``'AF_PIPE'`` est une chaîne de caractères de la forme :samp:" -"`r'\\\\\\\\.\\\\pipe\\\\{PipeName}'`. Pour utiliser :func:`Client` pour se " -"connecter à un tube nommé sur une machine distante appelée *ServerName*, il " -"faut utiliser une adresse de la forme :samp:`r'\\\\\\\\{ServerName}\\\\pipe\\" -"\\{PipeName}'`." +"Une adresse ``'AF_PIPE'`` est une chaîne de caractères de la forme :samp:`r'\\\\\\\\.\\\\pipe\\\\{PipeName}'`. " +"Pour utiliser :func:`Client` pour se connecter à un tube nommé sur une machine distante appelée *ServerName*, il " +"faut utiliser une adresse de la forme :samp:`r'\\\\\\\\{ServerName}\\\\pipe\\\\{PipeName}'`." #: library/multiprocessing.rst:2576 msgid "" -"Note that any string beginning with two backslashes is assumed by default to " -"be an ``'AF_PIPE'`` address rather than an ``'AF_UNIX'`` address." +"Note that any string beginning with two backslashes is assumed by default to be an ``'AF_PIPE'`` address rather " +"than an ``'AF_UNIX'`` address." msgstr "" -"Notez que toute chaîne commençant par deux antislashs est considérée par " -"défaut comme l'adresse d'un ``'AF_PIPE'`` plutôt qu'une adresse " -"``'AF_UNIX'``." +"Notez que toute chaîne commençant par deux antislashs est considérée par défaut comme l'adresse d'un " +"``'AF_PIPE'`` plutôt qu'une adresse ``'AF_UNIX'``." #: library/multiprocessing.rst:2583 msgid "Authentication keys" @@ -3854,55 +3117,42 @@ msgstr "Clés d'authentification" #: library/multiprocessing.rst:2585 msgid "" -"When one uses :meth:`Connection.recv `, the data received " -"is automatically unpickled. Unfortunately unpickling data from an untrusted " -"source is a security risk. Therefore :class:`Listener` and :func:`Client` " -"use the :mod:`hmac` module to provide digest authentication." +"When one uses :meth:`Connection.recv `, the data received is automatically unpickled. " +"Unfortunately unpickling data from an untrusted source is a security risk. Therefore :class:`Listener` and :func:" +"`Client` use the :mod:`hmac` module to provide digest authentication." msgstr "" -"Quand :meth:`Connection.recv ` est utilisée, les données " -"reçues sont automatiquement désérialisées par *pickle*. Malheureusement " -"désérialiser des données depuis une source non sûre constitue un risque de " -"sécurité. Par conséquent :class:`Listener` et :func:`Client` utilisent le " -"module :mod:`hmac` pour fournir une authentification par condensat." +"Quand :meth:`Connection.recv ` est utilisée, les données reçues sont automatiquement " +"désérialisées par *pickle*. Malheureusement désérialiser des données depuis une source non sûre constitue un " +"risque de sécurité. Par conséquent :class:`Listener` et :func:`Client` utilisent le module :mod:`hmac` pour " +"fournir une authentification par condensat." #: library/multiprocessing.rst:2591 msgid "" -"An authentication key is a byte string which can be thought of as a " -"password: once a connection is established both ends will demand proof that " -"the other knows the authentication key. (Demonstrating that both ends are " -"using the same key does **not** involve sending the key over the connection.)" +"An authentication key is a byte string which can be thought of as a password: once a connection is established " +"both ends will demand proof that the other knows the authentication key. (Demonstrating that both ends are using " +"the same key does **not** involve sending the key over the connection.)" msgstr "" -"Une clé d'authentification est une chaîne d'octets qui peut être vue comme " -"un mot de passe : quand une connexion est établie, les deux interlocuteurs " -"vont demander à l'autre une preuve qu'il connaît la clé d'authentification. " -"(Démontrer que les deux utilisent la même clé n'implique **pas** d'échanger " -"la clé sur la connexion.)" +"Une clé d'authentification est une chaîne d'octets qui peut être vue comme un mot de passe : quand une connexion " +"est établie, les deux interlocuteurs vont demander à l'autre une preuve qu'il connaît la clé d'authentification. " +"(Démontrer que les deux utilisent la même clé n'implique **pas** d'échanger la clé sur la connexion.)" #: library/multiprocessing.rst:2597 msgid "" -"If authentication is requested but no authentication key is specified then " -"the return value of ``current_process().authkey`` is used (see :class:" -"`~multiprocessing.Process`). This value will be automatically inherited by " -"any :class:`~multiprocessing.Process` object that the current process " -"creates. This means that (by default) all processes of a multi-process " -"program will share a single authentication key which can be used when " +"If authentication is requested but no authentication key is specified then the return value of " +"``current_process().authkey`` is used (see :class:`~multiprocessing.Process`). This value will be automatically " +"inherited by any :class:`~multiprocessing.Process` object that the current process creates. This means that (by " +"default) all processes of a multi-process program will share a single authentication key which can be used when " "setting up connections between themselves." msgstr "" -"Si l'authentification est requise et qu'aucune clé n'est spécifiée alors la " -"valeur de retour de ``current_process().authkey`` est utilisée (voir :class:" -"`~multiprocessing.Process`). Celle valeur est automatiquement héritée par " -"tout objet :class:`~multiprocessing.Process` créé par le processus courant. " -"Cela signifie que (par défaut) tous les processus d'un programme multi-" -"processus partageront une clé d'authentification unique qui peut être " -"utilisée pour mettre en place des connexions entre-eux." +"Si l'authentification est requise et qu'aucune clé n'est spécifiée alors la valeur de retour de " +"``current_process().authkey`` est utilisée (voir :class:`~multiprocessing.Process`). Celle valeur est " +"automatiquement héritée par tout objet :class:`~multiprocessing.Process` créé par le processus courant. Cela " +"signifie que (par défaut) tous les processus d'un programme multi-processus partageront une clé " +"d'authentification unique qui peut être utilisée pour mettre en place des connexions entre-eux." #: library/multiprocessing.rst:2605 -msgid "" -"Suitable authentication keys can also be generated by using :func:`os." -"urandom`." -msgstr "" -"Des clés d'authentification adaptées peuvent aussi être générées par :func:" -"`os.urandom`." +msgid "Suitable authentication keys can also be generated by using :func:`os.urandom`." +msgstr "Des clés d'authentification adaptées peuvent aussi être générées par :func:`os.urandom`." #: library/multiprocessing.rst:2609 msgid "Logging" @@ -3910,66 +3160,51 @@ msgstr "Journalisation" #: library/multiprocessing.rst:2611 msgid "" -"Some support for logging is available. Note, however, that the :mod:" -"`logging` package does not use process shared locks so it is possible " -"(depending on the handler type) for messages from different processes to get " -"mixed up." +"Some support for logging is available. Note, however, that the :mod:`logging` package does not use process " +"shared locks so it is possible (depending on the handler type) for messages from different processes to get mixed " +"up." msgstr "" -"Un certain support de la journalisation est disponible. Notez cependant que " -"le le paquet :mod:`logging` n'utilise pas de verrous partagés entre les " -"processus et il est donc possible (dépendant du type de gestionnaire) que " -"les messages de différents processus soient mélangés." +"Un certain support de la journalisation est disponible. Notez cependant que le le paquet :mod:`logging` n'utilise " +"pas de verrous partagés entre les processus et il est donc possible (dépendant du type de gestionnaire) que les " +"messages de différents processus soient mélangés." #: library/multiprocessing.rst:2618 -msgid "" -"Returns the logger used by :mod:`multiprocessing`. If necessary, a new one " -"will be created." -msgstr "" -"Renvoie le journaliseur utilisé par :mod:`multiprocessing`. Si nécessaire, " -"un nouveau sera créé." +msgid "Returns the logger used by :mod:`multiprocessing`. If necessary, a new one will be created." +msgstr "Renvoie le journaliseur utilisé par :mod:`multiprocessing`. Si nécessaire, un nouveau sera créé." #: library/multiprocessing.rst:2621 msgid "" -"When first created the logger has level :data:`logging.NOTSET` and no " -"default handler. Messages sent to this logger will not by default propagate " -"to the root logger." +"When first created the logger has level :data:`logging.NOTSET` and no default handler. Messages sent to this " +"logger will not by default propagate to the root logger." msgstr "" -"À sa première création le journaliseur a pour niveau :data:`logging.NOTSET` " -"et pas de gestionnaire par défaut. Les messages envoyés à ce journaliseur ne " -"seront pas propagés par défaut au journaliseur principal." +"À sa première création le journaliseur a pour niveau :data:`logging.NOTSET` et pas de gestionnaire par défaut. " +"Les messages envoyés à ce journaliseur ne seront pas propagés par défaut au journaliseur principal." #: library/multiprocessing.rst:2625 msgid "" -"Note that on Windows child processes will only inherit the level of the " -"parent process's logger -- any other customization of the logger will not be " -"inherited." +"Note that on Windows child processes will only inherit the level of the parent process's logger -- any other " +"customization of the logger will not be inherited." msgstr "" -"Notez que sous Windows les processus fils n'hériteront que du niveau du " -"journaliseur du processus parent – toute autre personnalisation du " -"journaliseur ne sera pas héritée." +"Notez que sous Windows les processus fils n'hériteront que du niveau du journaliseur du processus parent – toute " +"autre personnalisation du journaliseur ne sera pas héritée." #: library/multiprocessing.rst:2632 msgid "" -"This function performs a call to :func:`get_logger` but in addition to " -"returning the logger created by get_logger, it adds a handler which sends " -"output to :data:`sys.stderr` using format ``'[%(levelname)s/%(processName)s] " -"%(message)s'``." +"This function performs a call to :func:`get_logger` but in addition to returning the logger created by " +"get_logger, it adds a handler which sends output to :data:`sys.stderr` using format ``'[%(levelname)s/" +"%(processName)s] %(message)s'``." msgstr "" -"Cette fonction effectue un appel à :func:`get_logger` mais en plus de " -"renvoyer le journaliseur créé par *get_logger*, elle ajoute un gestionnaire " -"qui envoie la sortie sur :data:`sys.stderr` en utilisant le format " +"Cette fonction effectue un appel à :func:`get_logger` mais en plus de renvoyer le journaliseur créé par " +"*get_logger*, elle ajoute un gestionnaire qui envoie la sortie sur :data:`sys.stderr` en utilisant le format " "``'[%(levelname)s/%(processName)s] %(message)s'``." #: library/multiprocessing.rst:2637 msgid "Below is an example session with logging turned on::" -msgstr "" -"L'exemple ci-dessous présente une session avec la journalisation activée ::" +msgstr "L'exemple ci-dessous présente une session avec la journalisation activée ::" #: library/multiprocessing.rst:2652 msgid "For a full table of logging levels, see the :mod:`logging` module." -msgstr "" -"Pour un tableau complet des niveaux de journalisation, voir le module :mod:" -"`logging`." +msgstr "Pour un tableau complet des niveaux de journalisation, voir le module :mod:`logging`." #: library/multiprocessing.rst:2656 msgid "The :mod:`multiprocessing.dummy` module" @@ -3977,79 +3212,76 @@ msgstr "Le module :mod:`multiprocessing.dummy`" #: library/multiprocessing.rst:2661 msgid "" -":mod:`multiprocessing.dummy` replicates the API of :mod:`multiprocessing` " -"but is no more than a wrapper around the :mod:`threading` module." +":mod:`multiprocessing.dummy` replicates the API of :mod:`multiprocessing` but is no more than a wrapper around " +"the :mod:`threading` module." msgstr "" -":mod:`multiprocessing.dummy` réplique toute l'API de :mod:`multiprocessing` " -"mais n'est rien de plus qu'une interface autour du module :mod:`threading`." +":mod:`multiprocessing.dummy` réplique toute l'API de :mod:`multiprocessing` mais n'est rien de plus qu'une " +"interface autour du module :mod:`threading`." #: library/multiprocessing.rst:2666 msgid "" -"In particular, the ``Pool`` function provided by :mod:`multiprocessing." -"dummy` returns an instance of :class:`ThreadPool`, which is a subclass of :" -"class:`Pool` that supports all the same method calls but uses a pool of " +"In particular, the ``Pool`` function provided by :mod:`multiprocessing.dummy` returns an instance of :class:" +"`ThreadPool`, which is a subclass of :class:`Pool` that supports all the same method calls but uses a pool of " "worker threads rather than worker processes." msgstr "" -"En particulier, la fonction ``Pool`` du module :mod:`multiprocessing.dummy` " -"renvoie une instance de :class:`ThreadPool`, qui est une sous-classe de :" -"class:`Pool`. Elle a la même interface, mais elle utilise un pool de fils " -"d'exécution plutôt qu'un pool de processus." +"En particulier, la fonction ``Pool`` du module :mod:`multiprocessing.dummy` renvoie une instance de :class:" +"`ThreadPool`, qui est une sous-classe de :class:`Pool`. Elle a la même interface, mais elle utilise un pool de " +"fils d'exécution plutôt qu'un pool de processus." #: library/multiprocessing.rst:2674 msgid "" -"A thread pool object which controls a pool of worker threads to which jobs " -"can be submitted. :class:`ThreadPool` instances are fully interface " -"compatible with :class:`Pool` instances, and their resources must also be " -"properly managed, either by using the pool as a context manager or by " -"calling :meth:`~multiprocessing.pool.Pool.close` and :meth:`~multiprocessing." -"pool.Pool.terminate` manually." +"A thread pool object which controls a pool of worker threads to which jobs can be submitted. :class:`ThreadPool` " +"instances are fully interface compatible with :class:`Pool` instances, and their resources must also be properly " +"managed, either by using the pool as a context manager or by calling :meth:`~multiprocessing.pool.Pool.close` " +"and :meth:`~multiprocessing.pool.Pool.terminate` manually." msgstr "" +"Un objet qui contrôle un pool de fils d'exécution auquel des tâches peuvent être envoyées. L'interface des " +"instances de :class:`ThreadPool` est entièrement compatible avec celle des instances de :class:`Pool`, et leur " +"ressources doivent être aussi correctement gérées, soit en utilisant le pool avec un contexte, soit ou en " +"appelant explicitement :meth:`~multiprocessing.pool.Pool.close` et :meth:`~multiprocessing.pool.Pool.terminate`." #: library/multiprocessing.rst:2681 msgid "" -"*processes* is the number of worker threads to use. If *processes* is " -"``None`` then the number returned by :func:`os.cpu_count` is used." +"*processes* is the number of worker threads to use. If *processes* is ``None`` then the number returned by :func:" +"`os.cpu_count` is used." msgstr "" -"*processes* est le nombre de fils d'exécution à utiliser. Si *processes* est " -"``None``, le nombre renvoyé par :func:`os.cpu_count` est utilisé." +"*processes* est le nombre de fils d'exécution à utiliser. Si *processes* est ``None``, le nombre renvoyé par :" +"func:`os.cpu_count` est utilisé." #: library/multiprocessing.rst:2687 -msgid "" -"Unlike :class:`Pool`, *maxtasksperchild* and *context* cannot be provided." -msgstr "" -"À la différence de :class:`Pool`, *maxtasksperchild* et *context* ne peuvent " -"pas être passés en arguments." +msgid "Unlike :class:`Pool`, *maxtasksperchild* and *context* cannot be provided." +msgstr "À la différence de :class:`Pool`, *maxtasksperchild* et *context* ne peuvent pas être passés en arguments." #: library/multiprocessing.rst:2691 msgid "" -"A :class:`ThreadPool` shares the same interface as :class:`Pool`, which is " -"designed around a pool of processes and predates the introduction of the :" -"class:`concurrent.futures` module. As such, it inherits some operations " -"that don't make sense for a pool backed by threads, and it has its own type " -"for representing the status of asynchronous jobs, :class:`AsyncResult`, that " -"is not understood by any other libraries." +"A :class:`ThreadPool` shares the same interface as :class:`Pool`, which is designed around a pool of processes " +"and predates the introduction of the :class:`concurrent.futures` module. As such, it inherits some operations " +"that don't make sense for a pool backed by threads, and it has its own type for representing the status of " +"asynchronous jobs, :class:`AsyncResult`, that is not understood by any other libraries." msgstr "" +"La classe :class:`ThreadPool` a la même interface que la classe :class:`Pool`, dont l'implémentation repose sur " +"un pool de processus, et a été introduite avant le module :class:`concurrent.futures`. Par conséquent elle " +"implémente des opérations qui n'ont pas vraiment de sens pour un pool implémenté avec des fil d'exécution et " +"possède son propre type pour représenter le statut de tâches asynchrones, :class:`AsyncResult`, qui n'est pas " +"géré par les autres modules." #: library/multiprocessing.rst:2698 msgid "" -"Users should generally prefer to use :class:`concurrent.futures." -"ThreadPoolExecutor`, which has a simpler interface that was designed around " -"threads from the start, and which returns :class:`concurrent.futures.Future` " -"instances that are compatible with many other libraries, including :mod:" -"`asyncio`." +"Users should generally prefer to use :class:`concurrent.futures.ThreadPoolExecutor`, which has a simpler " +"interface that was designed around threads from the start, and which returns :class:`concurrent.futures.Future` " +"instances that are compatible with many other libraries, including :mod:`asyncio`." msgstr "" +"Il est souvent plus judicieux d'utiliser :class:`concurrent.futures.ThreadPoolExecutor` qui a une interface plus " +"simple, qui a été pensée dès l'origine pour les fils d'exécution et qui renvoie des instances de :class:" +"`concurrent.futures.Future` qui sont compatibles avec de nombreux modules, et en particulier avec :mod:`asyncio`." #: library/multiprocessing.rst:2708 msgid "Programming guidelines" msgstr "Lignes directrices de programmation" #: library/multiprocessing.rst:2710 -msgid "" -"There are certain guidelines and idioms which should be adhered to when " -"using :mod:`multiprocessing`." -msgstr "" -"Il y a certaines lignes directrices et idiomes auxquels il faut adhérer en " -"utilisant :mod:`multiprocessing`." +msgid "There are certain guidelines and idioms which should be adhered to when using :mod:`multiprocessing`." +msgstr "Il y a certaines lignes directrices et idiomes à respecter pour utiliser :mod:`multiprocessing`." #: library/multiprocessing.rst:2715 msgid "All start methods" @@ -4064,22 +3296,16 @@ msgid "Avoid shared state" msgstr "Éviter les états partagés" #: library/multiprocessing.rst:2721 -msgid "" -"As far as possible one should try to avoid shifting large amounts of data " -"between processes." -msgstr "" -"Autant que possible, vous devriez éviter de déplacer de larges données entre " -"les processus." +msgid "As far as possible one should try to avoid shifting large amounts of data between processes." +msgstr "Autant que possible, il faut éviter de transférer de gros volumes de données entre les processus." #: library/multiprocessing.rst:2724 msgid "" -"It is probably best to stick to using queues or pipes for communication " -"between processes rather than using the lower level synchronization " -"primitives." +"It is probably best to stick to using queues or pipes for communication between processes rather than using the " +"lower level synchronization primitives." msgstr "" -"Il est probablement meilleur de s'en tenir à l'utilisation de queues et " -"tubes pour la communication entre processus plutôt que d'utiliser des " -"primitives de synchronisation plus bas-niveau." +"Il est souvent plus judicieux de se borner à utiliser des files et des tubes pour gérer la communication entre " +"processus plutôt que d'utiliser des primitives de synchronisation plus bas-niveau." #: library/multiprocessing.rst:2728 msgid "Picklability" @@ -4087,28 +3313,21 @@ msgstr "Sérialisation" #: library/multiprocessing.rst:2730 msgid "Ensure that the arguments to the methods of proxies are picklable." -msgstr "" -"Assurez-vous que les arguments passés aux méthodes des mandataires soient " -"sérialisables (*pickables*)." +msgstr "Assurez-vous que les arguments passés aux méthodes des mandataires soient sérialisables (*pickables*)." #: library/multiprocessing.rst:2732 msgid "Thread safety of proxies" msgstr "Sûreté des mandataires à travers les fils d'exécution" #: library/multiprocessing.rst:2734 -msgid "" -"Do not use a proxy object from more than one thread unless you protect it " -"with a lock." +msgid "Do not use a proxy object from more than one thread unless you protect it with a lock." msgstr "" -"N'utilisez pas d'objet mandataire depuis plus d'un fil d'exécution à moins " -"que vous ne le protégiez avec un verrou." +"N'utilisez pas d'objet mandataire depuis plus d'un fil d'exécution à moins que vous ne le protégiez avec un " +"verrou." #: library/multiprocessing.rst:2737 -msgid "" -"(There is never a problem with different processes using the *same* proxy.)" -msgstr "" -"(Il n'y a jamais de problème avec plusieurs processus utilisant un *même* " -"mandataire.)" +msgid "(There is never a problem with different processes using the *same* proxy.)" +msgstr "Il n'y a jamais de problème à avoir plusieurs processus qui utilisent un *même* mandataire." #: library/multiprocessing.rst:2739 msgid "Joining zombie processes" @@ -4116,43 +3335,35 @@ msgstr "Attendre les processus zombies" #: library/multiprocessing.rst:2741 msgid "" -"On Unix when a process finishes but has not been joined it becomes a zombie. " -"There should never be very many because each time a new process starts (or :" -"func:`~multiprocessing.active_children` is called) all completed processes " -"which have not yet been joined will be joined. Also calling a finished " -"process's :meth:`Process.is_alive ` will " -"join the process. Even so it is probably good practice to explicitly join " -"all the processes that you start." -msgstr "" -"Sous Unix quand un processus se termine mais n'est pas attendu, il devient " -"un zombie. Il ne devrait jamais y en avoir beaucoup parce que chaque fois " -"qu'un nouveau processus démarre (ou que :func:`~multiprocessing." -"active_children` est appelée) tous les processus complétés qui n'ont pas été " -"attendus le seront. Aussi appeler la méthode :meth:`Process.is_alive " -"` d'un processus terminé attendra le " -"processus. Toutefois il est probablement une bonne pratique d'attendre " -"explicitement tous les processus que vous démarrez." +"On Unix when a process finishes but has not been joined it becomes a zombie. There should never be very many " +"because each time a new process starts (or :func:`~multiprocessing.active_children` is called) all completed " +"processes which have not yet been joined will be joined. Also calling a finished process's :meth:`Process." +"is_alive ` will join the process. Even so it is probably good practice to " +"explicitly join all the processes that you start." +msgstr "" +"Sous Unix quand un processus se termine mais n'est pas attendu, il devient un zombie. Il ne devrait jamais y en " +"avoir beaucoup parce que chaque fois qu'un nouveau processus démarre (ou que :func:`~multiprocessing." +"active_children` est appelée) tous les processus complétés qui n'ont pas été attendus le sont alors. Appeler la " +"méthode :meth:`Process.is_alive ` d'un processus terminé attend aussi le " +"processus. Toutefois, il est, en règle générale, conseillé d'attendre explicitement tous les processus que vous " +"démarrez." #: library/multiprocessing.rst:2749 msgid "Better to inherit than pickle/unpickle" -msgstr "Préférez hériter que sérialiser/désérialiser" +msgstr "Mieux vaut hériter que sérialiser - désérialiser" #: library/multiprocessing.rst:2751 msgid "" -"When using the *spawn* or *forkserver* start methods many types from :mod:" -"`multiprocessing` need to be picklable so that child processes can use " -"them. However, one should generally avoid sending shared objects to other " -"processes using pipes or queues. Instead you should arrange the program so " -"that a process which needs access to a shared resource created elsewhere can " -"inherit it from an ancestor process." -msgstr "" -"Quand vous utilisez les méthodes de démarrage *spawn* ou *forkserver*, de " -"nombreux types de :mod:`multiprocessing` nécessitent d'être sérialisées pour " -"que les processus enfants puissent les utiliser. Cependant, il faut " -"généralement éviter d'envoyer des objets partagés aux autres processus en " -"utilisant des tubes ou des queues. Vous devriez plutôt vous arranger pour " -"qu'un processus qui nécessite l'accès à une ressource partagée créée autre " -"part qu'il en hérite depuis un de ses processus ancêtres." +"When using the *spawn* or *forkserver* start methods many types from :mod:`multiprocessing` need to be picklable " +"so that child processes can use them. However, one should generally avoid sending shared objects to other " +"processes using pipes or queues. Instead you should arrange the program so that a process which needs access to a " +"shared resource created elsewhere can inherit it from an ancestor process." +msgstr "" +"Quand vous utilisez les méthodes de démarrage *spawn* ou *forkserver*, de nombreux types de :mod:" +"`multiprocessing` nécessitent d'être sérialisés pour que les processus enfants puissent les utiliser. Cependant, " +"il faut généralement éviter d'envoyer des objets partagés aux autres processus en utilisant des tubes ou des " +"files. Vous devez plutôt vous arranger pour qu'un processus qui nécessite l'accès à une ressource partagée créée " +"autre part qu'il en hérite depuis un de ses processus ancêtres." #: library/multiprocessing.rst:2759 msgid "Avoid terminating processes" @@ -4160,71 +3371,56 @@ msgstr "Éviter de terminer les processus" #: library/multiprocessing.rst:2761 msgid "" -"Using the :meth:`Process.terminate ` " -"method to stop a process is liable to cause any shared resources (such as " -"locks, semaphores, pipes and queues) currently being used by the process to " +"Using the :meth:`Process.terminate ` method to stop a process is liable to " +"cause any shared resources (such as locks, semaphores, pipes and queues) currently being used by the process to " "become broken or unavailable to other processes." msgstr "" -"Utiliser la méthode :meth:`Process.terminate ` pour stopper un processus risque de casser ou de rendre " -"indisponible aux autres processus des ressources partagées (comme des " -"verrous, sémaphores, tubes et queues) actuellement utilisée par le processus." +"Utiliser la méthode :meth:`Process.terminate ` pour stopper un processus " +"risque de casser ou de rendre indisponible aux autres processus des ressources partagées (comme des verrous, " +"sémaphores, tubes et files) actuellement utilisées par le processus." #: library/multiprocessing.rst:2767 msgid "" -"Therefore it is probably best to only consider using :meth:`Process." -"terminate ` on processes which never use " -"any shared resources." +"Therefore it is probably best to only consider using :meth:`Process.terminate ` on processes which never use any shared resources." msgstr "" -"Il est donc probablement préférable de n'utiliser :meth:`Process.terminate " -"` que sur les processus qui n'utilisent " -"jamais de ressources partagées." +"Il est donc préférable de n'utiliser :meth:`Process.terminate ` que sur les " +"processus qui n'utilisent jamais de ressources partagées." #: library/multiprocessing.rst:2771 msgid "Joining processes that use queues" -msgstr "Attendre les processus qui utilisent des queues" +msgstr "Attendre les processus qui utilisent des files" #: library/multiprocessing.rst:2773 msgid "" -"Bear in mind that a process that has put items in a queue will wait before " -"terminating until all the buffered items are fed by the \"feeder\" thread to " -"the underlying pipe. (The child process can call the :meth:`Queue." -"cancel_join_thread ` method of the " -"queue to avoid this behaviour.)" +"Bear in mind that a process that has put items in a queue will wait before terminating until all the buffered " +"items are fed by the \"feeder\" thread to the underlying pipe. (The child process can call the :meth:`Queue." +"cancel_join_thread ` method of the queue to avoid this behaviour.)" msgstr "" -"Gardez à l'esprit qu'un processus qui a placé des éléments dans une queue " -"attendra que tous les éléments mis en tampon soient consommés par le fil " -"d'exécution « consommateur » du tube sous-jacent avant de se terminer. (Le " -"processus enfant peut appeler la méthode :meth:`Queue.cancel_join_thread " -"` de la queue pour éviter ce " -"comportement.)" +"Gardez à l'esprit qu'un processus qui a placé des éléments dans une file attend que tous les éléments mis en " +"tampon soient consommés par le fil d'exécution « chargeur » du tube sous-jacent avant de se terminer (le " +"processus enfant peut appeler la méthode :meth:`Queue.cancel_join_thread ` de la queue pour éviter ce comportement)." #: library/multiprocessing.rst:2779 msgid "" -"This means that whenever you use a queue you need to make sure that all " -"items which have been put on the queue will eventually be removed before the " -"process is joined. Otherwise you cannot be sure that processes which have " -"put items on the queue will terminate. Remember also that non-daemonic " -"processes will be joined automatically." +"This means that whenever you use a queue you need to make sure that all items which have been put on the queue " +"will eventually be removed before the process is joined. Otherwise you cannot be sure that processes which have " +"put items on the queue will terminate. Remember also that non-daemonic processes will be joined automatically." msgstr "" -"Cela signifie que chaque fois que vous utilisez une queue vous devez vous " -"assurer que tous les éléments qui y ont été placés seront effectivement " -"supprimés avant que le processus ne soit attendu. Autrement vous ne pouvez " -"pas être sûr que les processus qui ont placé des éléments dans la queue se " -"termineront. Souvenez-vous aussi que tous les processus non *daemons* seront " -"attendus automatiquement." +"Cela signifie que chaque fois que vous utilisez une file, vous devez vous assurer que tous les éléments qui y ont " +"été placés ont été effectivement supprimés avant que le processus ne soit attendu. Autrement vous ne pouvez pas " +"être sûr que les processus qui ont placé des éléments dans la file se termineront. Souvenez-vous aussi que tous " +"les processus non *daemons* sont attendus automatiquement." #: library/multiprocessing.rst:2785 msgid "An example which will deadlock is the following::" msgstr "L'exemple suivant provoquera un interblocage ::" #: library/multiprocessing.rst:2799 -msgid "" -"A fix here would be to swap the last two lines (or simply remove the ``p." -"join()`` line)." +msgid "A fix here would be to swap the last two lines (or simply remove the ``p.join()`` line)." msgstr "" -"Une solution ici serait d'intervertir les deux dernières lignes (ou " -"simplement supprimer la ligne ``p.join()``)." +"Une solution ici serait d'intervertir les deux dernières lignes (ou simplement supprimer la ligne ``p.join()``)." #: library/multiprocessing.rst:2802 msgid "Explicitly pass resources to child processes" @@ -4232,30 +3428,24 @@ msgstr "Passer explicitement les ressources aux processus fils" #: library/multiprocessing.rst:2804 msgid "" -"On Unix using the *fork* start method, a child process can make use of a " -"shared resource created in a parent process using a global resource. " -"However, it is better to pass the object as an argument to the constructor " -"for the child process." +"On Unix using the *fork* start method, a child process can make use of a shared resource created in a parent " +"process using a global resource. However, it is better to pass the object as an argument to the constructor for " +"the child process." msgstr "" -"Sous Unix en utilisant la méthode de démarrage *fork*, un processus fils " -"peut utiliser une ressource partagée créée par un processus parent en " -"utilisant une ressource globale. Cependant, il est préférable de passer " -"l'objet en argument au constructeur du processus fils." +"Sous Unix en utilisant la méthode de démarrage *fork*, un processus fils peut utiliser une ressource partagée " +"créée par un processus parent en utilisant une ressource globale. Cependant, il est préférable de passer l'objet " +"en argument au constructeur du processus fils." #: library/multiprocessing.rst:2809 msgid "" -"Apart from making the code (potentially) compatible with Windows and the " -"other start methods this also ensures that as long as the child process is " -"still alive the object will not be garbage collected in the parent process. " -"This might be important if some resource is freed when the object is garbage " -"collected in the parent process." +"Apart from making the code (potentially) compatible with Windows and the other start methods this also ensures " +"that as long as the child process is still alive the object will not be garbage collected in the parent process. " +"This might be important if some resource is freed when the object is garbage collected in the parent process." msgstr "" -"En plus de rendre le code (potentiellement) compatible avec Windows et les " -"autres méthodes de démarrage, cela assure aussi que tant que le processus " -"fils est en vie, l'objet ne sera pas collecté par le ramasse-miettes du " -"processus parent. Cela peut être important si certaines ressources sont " -"libérées quand l'objet est collecté par le ramasse-miettes du processus " -"parent." +"En plus de rendre le code (potentiellement) compatible avec Windows et les autres méthodes de démarrage, cela " +"assure aussi que tant que le processus fils est en vie, l'objet ne sera pas collecté par le ramasse-miettes du " +"processus parent. Cela peut être important si certaines ressources sont libérées quand l'objet est collecté par " +"le ramasse-miettes du processus parent." #: library/multiprocessing.rst:2816 msgid "So for instance ::" @@ -4267,8 +3457,7 @@ msgstr "devrait être réécrit comme ::" #: library/multiprocessing.rst:2840 msgid "Beware of replacing :data:`sys.stdin` with a \"file like object\"" -msgstr "" -"Faire attention à remplacer :data:`sys.stdin` par un objet « *file-like* »" +msgstr "Faire attention à remplacer :data:`sys.stdin` par un objet simili-fichier" #: library/multiprocessing.rst:2842 msgid ":mod:`multiprocessing` originally unconditionally called::" @@ -4276,73 +3465,59 @@ msgstr "À l'origine, :mod:`multiprocessing` appelait inconditionnellement ::" #: library/multiprocessing.rst:2846 msgid "" -"in the :meth:`multiprocessing.Process._bootstrap` method --- this resulted " -"in issues with processes-in-processes. This has been changed to::" +"in the :meth:`multiprocessing.Process._bootstrap` method --- this resulted in issues with processes-in-processes. " +"This has been changed to::" msgstr "" -"dans la méthode :meth:`multiprocessing.Process._bootstrap` — cela provoquait " -"des problèmes avec les processus imbriqués. Cela peut être changé en ::" +"dans la méthode :meth:`multiprocessing.Process._bootstrap` — cela provoquait des problèmes avec les processus " +"imbriqués. Cela peut être changé en ::" #: library/multiprocessing.rst:2852 msgid "" -"Which solves the fundamental issue of processes colliding with each other " -"resulting in a bad file descriptor error, but introduces a potential danger " -"to applications which replace :func:`sys.stdin` with a \"file-like object\" " -"with output buffering. This danger is that if multiple processes call :meth:" -"`~io.IOBase.close()` on this file-like object, it could result in the same " -"data being flushed to the object multiple times, resulting in corruption." -msgstr "" -"Qui résout le problème fondamental des collisions entre processus provoquant " -"des erreurs de mauvais descripteurs de fichiers, mais introduit un potentiel " -"danger pour les applications qui remplacent :func:`sys.stdin` avec un " -"« *file-like object* » ayant une sortie *bufferisée*. Ce danger est que si " -"plusieurs processus appellent :meth:`~io.IOBase.close()` sur cet objet *file-" -"like*, cela peut amener les données à être transmises à l'objet à plusieurs " +"Which solves the fundamental issue of processes colliding with each other resulting in a bad file descriptor " +"error, but introduces a potential danger to applications which replace :func:`sys.stdin` with a \"file-like object" +"\" with output buffering. This danger is that if multiple processes call :meth:`~io.IOBase.close()` on this file-" +"like object, it could result in the same data being flushed to the object multiple times, resulting in corruption." +msgstr "" +"Qui résout le problème fondamental des collisions entre processus provoquant des erreurs de mauvais descripteurs " +"de fichiers, mais introduit un potentiel danger pour les applications qui remplacent :func:`sys.stdin` avec un " +"objet simili-fichier ayant une sortie mise en tampon. Ce danger est que si plusieurs processus appellent :meth:" +"`~io.IOBase.close()` sur cet objet, cela peut amener les données à être transmises à l'objet à plusieurs " "reprises, résultant en une corruption." #: library/multiprocessing.rst:2859 msgid "" -"If you write a file-like object and implement your own caching, you can make " -"it fork-safe by storing the pid whenever you append to the cache, and " -"discarding the cache when the pid changes. For example::" +"If you write a file-like object and implement your own caching, you can make it fork-safe by storing the pid " +"whenever you append to the cache, and discarding the cache when the pid changes. For example::" msgstr "" -"Si vous écrivez un objet *file-like* et implémentez votre propre cache, vous " -"pouvez le rendre sûr pour les *forks* en stockant le *pid* chaque fois que " -"vous ajoutez des données au cache, et annulez le cache quand le *pip* " -"change. Par exemple ::" +"Si vous écrivez un objet simili-fichier et implémentez votre propre cache, vous pouvez le rendre sûr pour les " +"*forks* en stockant le *pid* chaque fois que vous ajoutez des données au cache, et annulez le cache quand le " +"*pid* change. Par exemple ::" #: library/multiprocessing.rst:2871 -msgid "" -"For more information, see :issue:`5155`, :issue:`5313` and :issue:`5331`" -msgstr "" -"Pour plus d'informations, voir :issue:`5155`, :issue:`5313` et :issue:`5331`" +msgid "For more information, see :issue:`5155`, :issue:`5313` and :issue:`5331`" +msgstr "Pour plus d'informations, voir :issue:`5155`, :issue:`5313` et :issue:`5331`" #: library/multiprocessing.rst:2874 msgid "The *spawn* and *forkserver* start methods" msgstr "Les méthodes de démarrage *spawn* et *forkserver*" #: library/multiprocessing.rst:2876 -msgid "" -"There are a few extra restriction which don't apply to the *fork* start " -"method." -msgstr "" -"Certaines restrictions ne s'appliquent pas à la méthode de démarrage *fork*." +msgid "There are a few extra restriction which don't apply to the *fork* start method." +msgstr "Certaines restrictions ne s'appliquent pas à la méthode de démarrage *fork*." #: library/multiprocessing.rst:2879 msgid "More picklability" -msgstr "Plus de sérialisation" +msgstr "Contraintes supplémentaires sur la sérialisation" #: library/multiprocessing.rst:2881 msgid "" -"Ensure that all arguments to :meth:`Process.__init__` are picklable. Also, " -"if you subclass :class:`~multiprocessing.Process` then make sure that " -"instances will be picklable when the :meth:`Process.start ` method is called." +"Ensure that all arguments to :meth:`Process.__init__` are picklable. Also, if you subclass :class:" +"`~multiprocessing.Process` then make sure that instances will be picklable when the :meth:`Process.start " +"` method is called." msgstr "" -"Assurez-vous que tous les argument de :meth:`Process.__init__` sont " -"sérialisables avec *pickle*. Aussi, si vous héritez de :class:" -"`~multiprocessing.Process`, assurez-vous que toutes les instances sont " -"sérialisables quand la méthode :meth:`Process.start ` est appelée." +"Assurez-vous que tous les argument de :meth:`Process.__init__` sont sérialisables avec *pickle*. Aussi, si vous " +"héritez de :class:`~multiprocessing.Process`, assurez-vous que toutes les instances sont sérialisables quand la " +"méthode :meth:`Process.start ` est appelée." #: library/multiprocessing.rst:2886 msgid "Global variables" @@ -4350,78 +3525,61 @@ msgstr "Variables globales" #: library/multiprocessing.rst:2888 msgid "" -"Bear in mind that if code run in a child process tries to access a global " -"variable, then the value it sees (if any) may not be the same as the value " -"in the parent process at the time that :meth:`Process.start ` was called." +"Bear in mind that if code run in a child process tries to access a global variable, then the value it sees (if " +"any) may not be the same as the value in the parent process at the time that :meth:`Process.start " +"` was called." msgstr "" -"Gardez en tête que si le code exécuté dans un processus fils essaie " -"d'accéder à une variable globale, alors la valeur qu'il voit (s'il y en a " -"une) pourrait ne pas être la même que la valeur du processus parent au " -"moment même où :meth:`Process.start ` est " -"appelée." +"Gardez en tête que si le code exécuté dans un processus fils essaie d'accéder à une variable globale, alors la " +"valeur qu'il voit (s'il y en a une) pourrait ne pas être la même que la valeur du processus parent au moment même " +"où :meth:`Process.start ` est appelée." #: library/multiprocessing.rst:2893 -msgid "" -"However, global variables which are just module level constants cause no " -"problems." -msgstr "" -"Cependant, les variables globales qui sont juste des constantes de modules " -"ne posent pas de problèmes." +msgid "However, global variables which are just module level constants cause no problems." +msgstr "Cependant, les variables globales qui sont juste des constantes de modules ne posent pas de problèmes." #: library/multiprocessing.rst:2896 msgid "Safe importing of main module" -msgstr "Importation sûre du module principal" +msgstr "Importation sécurisée du module principal" #: library/multiprocessing.rst:2898 msgid "" -"Make sure that the main module can be safely imported by a new Python " -"interpreter without causing unintended side effects (such a starting a new " -"process)." +"Make sure that the main module can be safely imported by a new Python interpreter without causing unintended side " +"effects (such a starting a new process)." msgstr "" -"Assurez-vous que le module principal peut être importé en toute sécurité par " -"un nouvel interpréteur Python sans causer d'effets de bord inattendus (comme " -"le démarrage d'un nouveau processus)." +"Assurez-vous que le module principal peut être importé en toute sécurité par un nouvel interpréteur Python sans " +"causer d'effets de bord inattendus (comme le démarrage d'un nouveau processus)." #: library/multiprocessing.rst:2902 msgid "" -"For example, using the *spawn* or *forkserver* start method running the " -"following module would fail with a :exc:`RuntimeError`::" +"For example, using the *spawn* or *forkserver* start method running the following module would fail with a :exc:" +"`RuntimeError`::" msgstr "" -"Par exemple, utiliser la méthode de démarrage *spawn* ou *forkserver* pour " -"lancer le module suivant échouerait avec une :exc:`RuntimeError` ::" +"Par exemple, utiliser la méthode de démarrage *spawn* ou *forkserver* pour lancer le module suivant échouerait " +"avec une :exc:`RuntimeError` ::" #: library/multiprocessing.rst:2914 msgid "" -"Instead one should protect the \"entry point\" of the program by using ``if " -"__name__ == '__main__':`` as follows::" +"Instead one should protect the \"entry point\" of the program by using ``if __name__ == '__main__':`` as follows::" msgstr "" -"Vous devriez plutôt protéger le « point d'entrée » du programme en utilisant " -"``if __name__ == '__main__':`` comme suit ::" +"Vous devriez plutôt protéger le « point d'entrée » du programme en utilisant ``if __name__ == '__main__':`` comme " +"suit ::" #: library/multiprocessing.rst:2928 -msgid "" -"(The ``freeze_support()`` line can be omitted if the program will be run " -"normally instead of frozen.)" +msgid "(The ``freeze_support()`` line can be omitted if the program will be run normally instead of frozen.)" msgstr "" -"(La ligne ``freeze_support()`` peut être omise si le programme est " -"uniquement lancé normalement et pas figé.)" +"(La ligne ``freeze_support()`` peut être omise si le programme est uniquement lancé normalement et pas figé.)" #: library/multiprocessing.rst:2931 msgid "" -"This allows the newly spawned Python interpreter to safely import the module " -"and then run the module's ``foo()`` function." +"This allows the newly spawned Python interpreter to safely import the module and then run the module's ``foo()`` " +"function." msgstr "" -"Cela permet aux interpréteurs Python fraîchement instanciés d'importer en " -"toute sécurité le module et d'exécution ensuite la fonction ``foo()``." +"Cela permet aux interpréteurs Python fraîchement instanciés d'importer en toute sécurité le module et d'exécution " +"ensuite la fonction ``foo()``." #: library/multiprocessing.rst:2934 -msgid "" -"Similar restrictions apply if a pool or manager is created in the main " -"module." -msgstr "" -"Des restrictions similaires s'appliquent si une *pool* ou un gestionnaire " -"est créé dans le module principal." +msgid "Similar restrictions apply if a pool or manager is created in the main module." +msgstr "Des restrictions similaires s'appliquent si un pool ou un gestionnaire est créé dans le module principal." #: library/multiprocessing.rst:2941 msgid "Examples" @@ -4429,9 +3587,7 @@ msgstr "Exemples" #: library/multiprocessing.rst:2943 msgid "Demonstration of how to create and use customized managers and proxies:" -msgstr "" -"Démonstration de comment créer et utiliser des gestionnaires et mandataires " -"personnalisés :" +msgstr "Démonstration de comment créer et utiliser des gestionnaires et mandataires personnalisés :" #: library/multiprocessing.rst:2949 msgid "Using :class:`~multiprocessing.pool.Pool`:" @@ -4439,11 +3595,10 @@ msgstr "En utilisant :class:`~multiprocessing.pool.Pool` :" #: library/multiprocessing.rst:2955 msgid "" -"An example showing how to use queues to feed tasks to a collection of worker " -"processes and collect the results:" +"An example showing how to use queues to feed tasks to a collection of worker processes and collect the results:" msgstr "" -"Un exemple montrant comment utiliser des queues pour alimenter en tâches une " -"collection de processus *workers* et collecter les résultats :" +"Un exemple montrant comment utiliser des files pour alimenter en tâches une collection de processus *workers* et " +"collecter les résultats :" #~ msgid "An ``'AF_PIPE'`` address is a string of the form" #~ msgstr "Une adresse ``'AF_PIPE'`` est une chaîne de la forme" diff --git a/library/multiprocessing.shared_memory.po b/library/multiprocessing.shared_memory.po index 760c4d085..a191d71f5 100644 --- a/library/multiprocessing.shared_memory.po +++ b/library/multiprocessing.shared_memory.po @@ -7,7 +7,7 @@ msgstr "" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2020-08-24 09:01+0200\n" "PO-Revision-Date: 2019-09-04 11:44+0200\n" -"Last-Translator: FULL NAME \n" +"Last-Translator: Antoine Wecxsteen\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" @@ -310,8 +310,8 @@ msgid "" "slicing." msgstr "" "Construit un objet muable compatible avec le type liste dont toutes les " -"valeurs sont stockées dans un bloc de mémoire partagée. Ceci réduit le type " -"les valeurs pouvant être stockées aux types natifs ``int``, ``float``, " +"valeurs sont stockées dans un bloc de mémoire partagée. Ceci limite le type " +"des valeurs pouvant être stockées aux types natifs ``int``, ``float``, " "``bool``, ``str`` (de moins de 10 Mo chacune), ``bytes`` (de moins de 10 Mo " "chacun) et ``None``. Une autre différence majeure avec une ``list`` native " "réside dans le fait qu'il est impossible de changer la taille (c.-à-d. pas " From f53590c6738e3dd8d5f4d7cb4d6a140d50435d44 Mon Sep 17 00:00:00 2001 From: Antoine Wecxsteen Date: Sat, 17 Jul 2021 15:57:42 +0200 Subject: [PATCH 03/10] Indentation --- Makefile | 5 - library/multiprocessing.po | 4160 ++++++++++++++++++++++-------------- 2 files changed, 2511 insertions(+), 1654 deletions(-) diff --git a/Makefile b/Makefile index d087c51f6..b6538a9e2 100644 --- a/Makefile +++ b/Makefile @@ -88,11 +88,6 @@ ensure_prerequisites: echo " git clone $(UPSTREAM) $(CPYTHON_PATH)"; \ exit 1; \ fi - @if [ -n "$$(git -C $(CPYTHON_PATH) status --porcelain)" ]; then \ - echo "Your cpython clone at $(CPYTHON_PATH) is not clean."; \ - echo "In order to avoid breaking things, please clean it first."; \ - exit 1; \ - fi @if ! (blurb help >/dev/null 2>&1 && sphinx-build --version >/dev/null 2>&1); then \ git -C $(CPYTHON_PATH) checkout $(BRANCH); \ echo "You're missing dependencies, please enable a venv and install:"; \ diff --git a/library/multiprocessing.po b/library/multiprocessing.po index 3e2b5c69c..e26450cd7 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -29,34 +29,44 @@ msgstr "Introduction" #: library/multiprocessing.rst:14 msgid "" -":mod:`multiprocessing` is a package that supports spawning processes using an API similar to the :mod:`threading` " -"module. The :mod:`multiprocessing` package offers both local and remote concurrency, effectively side-stepping " -"the :term:`Global Interpreter Lock ` by using subprocesses instead of threads. Due to " -"this, the :mod:`multiprocessing` module allows the programmer to fully leverage multiple processors on a given " -"machine. It runs on both Unix and Windows." -msgstr "" -":mod:`multiprocessing` est un paquet qui permet l'instanciation de processus via la même API que le module :mod:" -"`threading`. Le paquet :mod:`multiprocessing` permet la programmation concurrente sur une même machine ou entre " -"machines. Il permet de contourner les problèmes du :term:`verrou global de l'interpréteur (GIL) ` en utilisant des processus plutôt que des fils d'exécution. Ainsi, le module :mod:" -"`multiprocessing` permet au développeur d'exploiter au mieux tous les processeurs d'une machine. Il tourne à la " -"fois sur les systèmes Unix et Windows." +":mod:`multiprocessing` is a package that supports spawning processes using " +"an API similar to the :mod:`threading` module. The :mod:`multiprocessing` " +"package offers both local and remote concurrency, effectively side-stepping " +"the :term:`Global Interpreter Lock ` by using " +"subprocesses instead of threads. Due to this, the :mod:`multiprocessing` " +"module allows the programmer to fully leverage multiple processors on a " +"given machine. It runs on both Unix and Windows." +msgstr "" +":mod:`multiprocessing` est un paquet qui permet l'instanciation de processus " +"via la même API que le module :mod:`threading`. Le paquet :mod:" +"`multiprocessing` permet la programmation concurrente sur une même machine " +"ou entre machines. Il permet de contourner les problèmes du :term:`verrou " +"global de l'interpréteur (GIL) ` en " +"utilisant des processus plutôt que des fils d'exécution. Ainsi, le module :" +"mod:`multiprocessing` permet au développeur d'exploiter au mieux tous les " +"processeurs d'une machine. Il tourne à la fois sur les systèmes Unix et " +"Windows." #: library/multiprocessing.rst:23 msgid "" -"The :mod:`multiprocessing` module also introduces APIs which do not have analogs in the :mod:`threading` module. " -"A prime example of this is the :class:`~multiprocessing.pool.Pool` object which offers a convenient means of " -"parallelizing the execution of a function across multiple input values, distributing the input data across " -"processes (data parallelism). The following example demonstrates the common practice of defining such functions " -"in a module so that child processes can successfully import that module. This basic example of data parallelism " -"using :class:`~multiprocessing.pool.Pool`, ::" -msgstr "" -"Le module :mod:`multiprocessing` introduit aussi des API sans analogues dans le module :mod:`threading`. Un " -"exemple est l'objet :class:`~multiprocessing.pool.Pool` qui offre un moyen simple de paralléliser l'exécution " -"d'une fonction sur plusieurs valeurs d'entrée, en distribuant ces valeurs entre les processus (parallélisme de " -"données). L'exemple suivant présente la manière classique de définir une telle fonction dans un module afin que " -"les processus fils puissent importer ce module avec succès. Cet exemple basique de parallélisme de données, " -"utilisant :class:`~multiprocessing.pool.Pool`, ::" +"The :mod:`multiprocessing` module also introduces APIs which do not have " +"analogs in the :mod:`threading` module. A prime example of this is the :" +"class:`~multiprocessing.pool.Pool` object which offers a convenient means of " +"parallelizing the execution of a function across multiple input values, " +"distributing the input data across processes (data parallelism). The " +"following example demonstrates the common practice of defining such " +"functions in a module so that child processes can successfully import that " +"module. This basic example of data parallelism using :class:" +"`~multiprocessing.pool.Pool`, ::" +msgstr "" +"Le module :mod:`multiprocessing` introduit aussi des API sans analogues dans " +"le module :mod:`threading`. Un exemple est l'objet :class:`~multiprocessing." +"pool.Pool` qui offre un moyen simple de paralléliser l'exécution d'une " +"fonction sur plusieurs valeurs d'entrée, en distribuant ces valeurs entre " +"les processus (parallélisme de données). L'exemple suivant présente la " +"manière classique de définir une telle fonction dans un module afin que les " +"processus fils puissent importer ce module avec succès. Cet exemple basique " +"de parallélisme de données, utilisant :class:`~multiprocessing.pool.Pool`, ::" #: library/multiprocessing.rst:41 msgid "will print to standard output ::" @@ -68,25 +78,30 @@ msgstr "La classe :class:`Process`" #: library/multiprocessing.rst:49 msgid "" -"In :mod:`multiprocessing`, processes are spawned by creating a :class:`Process` object and then calling its :meth:" -"`~Process.start` method. :class:`Process` follows the API of :class:`threading.Thread`. A trivial example of a " -"multiprocess program is ::" +"In :mod:`multiprocessing`, processes are spawned by creating a :class:" +"`Process` object and then calling its :meth:`~Process.start` method. :class:" +"`Process` follows the API of :class:`threading.Thread`. A trivial example " +"of a multiprocess program is ::" msgstr "" -"Dans le module :mod:`multiprocessing`, les processus sont instanciés en créant un objet :class:`Process` et en " -"appelant sa méthode :meth:`~Process.start`. La classe :class:`Process` suit la même API que :class:`threading." +"Dans le module :mod:`multiprocessing`, les processus sont instanciés en " +"créant un objet :class:`Process` et en appelant sa méthode :meth:`~Process." +"start`. La classe :class:`Process` suit la même API que :class:`threading." "Thread`. Un exemple trivial d'un programme multi-processus est ::" #: library/multiprocessing.rst:64 -msgid "To show the individual process IDs involved, here is an expanded example::" -msgstr "Pour afficher les IDs des processus impliqués, voici un exemple plus étoffé ::" +msgid "" +"To show the individual process IDs involved, here is an expanded example::" +msgstr "" +"Pour afficher les IDs des processus impliqués, voici un exemple plus " +"étoffé ::" #: library/multiprocessing.rst:85 msgid "" -"For an explanation of why the ``if __name__ == '__main__'`` part is necessary, see :ref:`multiprocessing-" -"programming`." +"For an explanation of why the ``if __name__ == '__main__'`` part is " +"necessary, see :ref:`multiprocessing-programming`." msgstr "" -"La nécessité de la ligne ``if __name__ == '__main__'`` est expliquée dans la section :ref:`multiprocessing-" -"programming`." +"La nécessité de la ligne ``if __name__ == '__main__'`` est expliquée dans la " +"section :ref:`multiprocessing-programming`." #: library/multiprocessing.rst:91 msgid "Contexts and start methods" @@ -94,11 +109,11 @@ msgstr "Contextes et méthodes de démarrage" #: library/multiprocessing.rst:95 msgid "" -"Depending on the platform, :mod:`multiprocessing` supports three ways to start a process. These *start methods* " -"are" +"Depending on the platform, :mod:`multiprocessing` supports three ways to " +"start a process. These *start methods* are" msgstr "" -"Selon la plateforme, :mod:`multiprocessing` gère trois manières de démarrer un processus. Ces *méthodes de " -"démarrage* sont" +"Selon la plateforme, :mod:`multiprocessing` gère trois manières de démarrer " +"un processus. Ces *méthodes de démarrage* sont" #: library/multiprocessing.rst:106 msgid "*spawn*" @@ -106,15 +121,19 @@ msgstr "*spawn*" #: library/multiprocessing.rst:99 msgid "" -"The parent process starts a fresh python interpreter process. The child process will only inherit those " -"resources necessary to run the process object's :meth:`~Process.run` method. In particular, unnecessary file " -"descriptors and handles from the parent process will not be inherited. Starting a process using this method is " -"rather slow compared to using *fork* or *forkserver*." +"The parent process starts a fresh python interpreter process. The child " +"process will only inherit those resources necessary to run the process " +"object's :meth:`~Process.run` method. In particular, unnecessary file " +"descriptors and handles from the parent process will not be inherited. " +"Starting a process using this method is rather slow compared to using *fork* " +"or *forkserver*." msgstr "" -"Le processus parent démarre un processus neuf avec un interpréteur Python. Le processus fils hérite uniquement " -"des ressources nécessaires pour exécuter la méthode :meth:`~Process.run` de l'objet associé au processus. En " -"particulier, les descripteurs de fichiers superflus et gérés par le processus parent ne sont pas hérités. " -"Démarrer un processus en utilisant cette méthode est plutôt lent par rapport à *fork* ou *forkserver*." +"Le processus parent démarre un processus neuf avec un interpréteur Python. " +"Le processus fils hérite uniquement des ressources nécessaires pour exécuter " +"la méthode :meth:`~Process.run` de l'objet associé au processus. En " +"particulier, les descripteurs de fichiers superflus et gérés par le " +"processus parent ne sont pas hérités. Démarrer un processus en utilisant " +"cette méthode est plutôt lent par rapport à *fork* ou *forkserver*." #: library/multiprocessing.rst:106 msgid "Available on Unix and Windows. The default on Windows and macOS." @@ -126,13 +145,16 @@ msgstr "*fork*" #: library/multiprocessing.rst:109 msgid "" -"The parent process uses :func:`os.fork` to fork the Python interpreter. The child process, when it begins, is " -"effectively identical to the parent process. All resources of the parent are inherited by the child process. " +"The parent process uses :func:`os.fork` to fork the Python interpreter. The " +"child process, when it begins, is effectively identical to the parent " +"process. All resources of the parent are inherited by the child process. " "Note that safely forking a multithreaded process is problematic." msgstr "" -"Le processus parent utilise :func:`os.fork` pour *forker* l'interpréteur Python. Le processus fils, quand il " -"démarre, est effectivement identique au processus parent. Toutes les ressources du parent sont héritées par le " -"fils. Notez qu'il est problématique de *forker* sans danger un processus *multi-threadé*." +"Le processus parent utilise :func:`os.fork` pour *forker* l'interpréteur " +"Python. Le processus fils, quand il démarre, est effectivement identique au " +"processus parent. Toutes les ressources du parent sont héritées par le fils. " +"Notez qu'il est problématique de *forker* sans danger un processus *multi-" +"threadé*." #: library/multiprocessing.rst:115 msgid "Available on Unix only. The default on Unix." @@ -144,105 +166,132 @@ msgstr "*forkserver*" #: library/multiprocessing.rst:118 msgid "" -"When the program starts and selects the *forkserver* start method, a server process is started. From then on, " -"whenever a new process is needed, the parent process connects to the server and requests that it fork a new " -"process. The fork server process is single threaded so it is safe for it to use :func:`os.fork`. No unnecessary " -"resources are inherited." +"When the program starts and selects the *forkserver* start method, a server " +"process is started. From then on, whenever a new process is needed, the " +"parent process connects to the server and requests that it fork a new " +"process. The fork server process is single threaded so it is safe for it to " +"use :func:`os.fork`. No unnecessary resources are inherited." msgstr "" -"Quand le programme démarre et choisit la méthode de démarrage *forkserver*, un processus serveur est lancé. Dès " -"lors, chaque fois qu'un nouveau processus est nécessaire, le processus parent se connecte au serveur et lui " -"demande de *forker* un nouveau processus. Le processus serveur de *fork* n'utilisant qu'un seul fil d'exécution, " -"il peut utiliser :func:`os.fork` sans danger. Les ressources superflues ne sont pas héritées." +"Quand le programme démarre et choisit la méthode de démarrage *forkserver*, " +"un processus serveur est lancé. Dès lors, chaque fois qu'un nouveau " +"processus est nécessaire, le processus parent se connecte au serveur et lui " +"demande de *forker* un nouveau processus. Le processus serveur de *fork* " +"n'utilisant qu'un seul fil d'exécution, il peut utiliser :func:`os.fork` " +"sans danger. Les ressources superflues ne sont pas héritées." #: library/multiprocessing.rst:125 -msgid "Available on Unix platforms which support passing file descriptors over Unix pipes." +msgid "" +"Available on Unix platforms which support passing file descriptors over Unix " +"pipes." msgstr "" -"Disponible sur les plateformes Unix qui acceptent le passage de descripteurs de fichiers à travers des tubes " -"(*pipes*) Unix." +"Disponible sur les plateformes Unix qui acceptent le passage de descripteurs " +"de fichiers à travers des tubes (*pipes*) Unix." #: library/multiprocessing.rst:130 msgid "" -"On macOS, the *spawn* start method is now the default. The *fork* start method should be considered unsafe as it " -"can lead to crashes of the subprocess. See :issue:`33725`." +"On macOS, the *spawn* start method is now the default. The *fork* start " +"method should be considered unsafe as it can lead to crashes of the " +"subprocess. See :issue:`33725`." msgstr "" -"sur macOS, la méthode de démarrage *spawn* est maintenant la méthode par défaut. La méthode de démarrage *fork* " -"doit être considérée comme dangereuse car elle peut entraîner des plantages du sous-processus. Voir :issue:" -"`33725`." +"sur macOS, la méthode de démarrage *spawn* est maintenant la méthode par " +"défaut. La méthode de démarrage *fork* doit être considérée comme dangereuse " +"car elle peut entraîner des plantages du sous-processus. Voir :issue:`33725`." #: library/multiprocessing.rst:134 msgid "" -"*spawn* added on all unix platforms, and *forkserver* added for some unix platforms. Child processes no longer " -"inherit all of the parents inheritable handles on Windows." +"*spawn* added on all unix platforms, and *forkserver* added for some unix " +"platforms. Child processes no longer inherit all of the parents inheritable " +"handles on Windows." msgstr "" -"ajout de *spawn* à toutes les plateformes Unix et ajout de *forkserver* à certaines plateformes Unix. Les " -"processus fils n'héritent plus de tous les descripteurs héritables du parent sous Windows." +"ajout de *spawn* à toutes les plateformes Unix et ajout de *forkserver* à " +"certaines plateformes Unix. Les processus fils n'héritent plus de tous les " +"descripteurs héritables du parent sous Windows." #: library/multiprocessing.rst:140 msgid "" -"On Unix using the *spawn* or *forkserver* start methods will also start a *resource tracker* process which tracks " -"the unlinked named system resources (such as named semaphores or :class:`~multiprocessing.shared_memory." -"SharedMemory` objects) created by processes of the program. When all processes have exited the resource tracker " -"unlinks any remaining tracked object. Usually there should be none, but if a process was killed by a signal there " -"may be some \"leaked\" resources. (Neither leaked semaphores nor shared memory segments will be automatically " -"unlinked until the next reboot. This is problematic for both objects because the system allows only a limited " -"number of named semaphores, and shared memory segments occupy some space in the main memory.)" -msgstr "" -"Sous Unix, utiliser les méthodes de démarrage *spawn* ou *forkserver* démarre aussi un processus de *suivi de " -"ressources* qui détecte les ressources systèmes non-libérées (comme des sémaphores nommés ou des objets :class:" -"`~multiprocessing.shared_memory.SharedMemory`) créés par les processus du programme. Quand tous les processus " -"sont terminés, le traqueur de ressources libère tous les objets restants. Normalement, il ne devrait pas y en " -"avoir, mais si un processus a été tué par un signal, certaines ressources peuvent avoir été « perdues ». Ni les " -"sémaphores ni les blocs de mémoire partagée ne sont libérés avant le prochain redémarrage. C'est problématique " -"dans les deux cas car le système n'autorise qu'un nombre limité de sémaphores et parce que les blocs de mémoire " -"partagée prennent de la place dans la mémoire principale." +"On Unix using the *spawn* or *forkserver* start methods will also start a " +"*resource tracker* process which tracks the unlinked named system resources " +"(such as named semaphores or :class:`~multiprocessing.shared_memory." +"SharedMemory` objects) created by processes of the program. When all " +"processes have exited the resource tracker unlinks any remaining tracked " +"object. Usually there should be none, but if a process was killed by a " +"signal there may be some \"leaked\" resources. (Neither leaked semaphores " +"nor shared memory segments will be automatically unlinked until the next " +"reboot. This is problematic for both objects because the system allows only " +"a limited number of named semaphores, and shared memory segments occupy some " +"space in the main memory.)" +msgstr "" +"Sous Unix, utiliser les méthodes de démarrage *spawn* ou *forkserver* " +"démarre aussi un processus de *suivi de ressources* qui détecte les " +"ressources systèmes non-libérées (comme des sémaphores nommés ou des objets :" +"class:`~multiprocessing.shared_memory.SharedMemory`) créés par les processus " +"du programme. Quand tous les processus sont terminés, le traqueur de " +"ressources libère tous les objets restants. Normalement, il ne devrait pas y " +"en avoir, mais si un processus a été tué par un signal, certaines ressources " +"peuvent avoir été « perdues ». Ni les sémaphores ni les blocs de mémoire " +"partagée ne sont libérés avant le prochain redémarrage. C'est problématique " +"dans les deux cas car le système n'autorise qu'un nombre limité de " +"sémaphores et parce que les blocs de mémoire partagée prennent de la place " +"dans la mémoire principale." #: library/multiprocessing.rst:153 msgid "" -"To select a start method you use the :func:`set_start_method` in the ``if __name__ == '__main__'`` clause of the " -"main module. For example::" +"To select a start method you use the :func:`set_start_method` in the ``if " +"__name__ == '__main__'`` clause of the main module. For example::" msgstr "" -"Pour sélectionner une méthode de démarrage, utilisez la fonction :func:`set_start_method` dans la clause ``if " -"__name__ == '__main__'`` du module principal. Par exemple ::" +"Pour sélectionner une méthode de démarrage, utilisez la fonction :func:" +"`set_start_method` dans la clause ``if __name__ == '__main__'`` du module " +"principal. Par exemple ::" #: library/multiprocessing.rst:170 -msgid ":func:`set_start_method` should not be used more than once in the program." -msgstr ":func:`set_start_method` ne doit pas être utilisée plus d'une fois dans le programme." +msgid "" +":func:`set_start_method` should not be used more than once in the program." +msgstr "" +":func:`set_start_method` ne doit pas être utilisée plus d'une fois dans le " +"programme." #: library/multiprocessing.rst:173 msgid "" -"Alternatively, you can use :func:`get_context` to obtain a context object. Context objects have the same API as " -"the multiprocessing module, and allow one to use multiple start methods in the same program. ::" +"Alternatively, you can use :func:`get_context` to obtain a context object. " +"Context objects have the same API as the multiprocessing module, and allow " +"one to use multiple start methods in the same program. ::" msgstr "" -"Alternativement, vous pouvez utiliser :func:`get_context` pour obtenir un contexte. Les contextes ont la même API " -"que le module *multiprocessing*, et permettent l'utilisation de plusieurs méthodes de démarrage dans un même " +"Alternativement, vous pouvez utiliser :func:`get_context` pour obtenir un " +"contexte. Les contextes ont la même API que le module *multiprocessing*, et " +"permettent l'utilisation de plusieurs méthodes de démarrage dans un même " "programme. ::" #: library/multiprocessing.rst:191 msgid "" -"Note that objects related to one context may not be compatible with processes for a different context. In " -"particular, locks created using the *fork* context cannot be passed to processes started using the *spawn* or " +"Note that objects related to one context may not be compatible with " +"processes for a different context. In particular, locks created using the " +"*fork* context cannot be passed to processes started using the *spawn* or " "*forkserver* start methods." msgstr "" -"Notez que les objets relatifs à un contexte ne sont pas forcément compatibles avec les processus d'un contexte " -"différent. En particulier, les verrous créés avec le contexte *fork* ne peuvent pas être passés aux processus " -"lancés avec les méthodes *spawn* ou *forkserver*." +"Notez que les objets relatifs à un contexte ne sont pas forcément " +"compatibles avec les processus d'un contexte différent. En particulier, les " +"verrous créés avec le contexte *fork* ne peuvent pas être passés aux " +"processus lancés avec les méthodes *spawn* ou *forkserver*." #: library/multiprocessing.rst:196 msgid "" -"A library which wants to use a particular start method should probably use :func:`get_context` to avoid " -"interfering with the choice of the library user." +"A library which wants to use a particular start method should probably use :" +"func:`get_context` to avoid interfering with the choice of the library user." msgstr "" -"Une bibliothèque qui veut utiliser une méthode de démarrage particulière devrait probablement faire appel à :func:" -"`get_context` pour éviter d'interférer avec le choix de l'utilisateur de la bibliothèque." +"Une bibliothèque qui veut utiliser une méthode de démarrage particulière " +"devrait probablement faire appel à :func:`get_context` pour éviter " +"d'interférer avec le choix de l'utilisateur de la bibliothèque." #: library/multiprocessing.rst:202 msgid "" -"The ``'spawn'`` and ``'forkserver'`` start methods cannot currently be used with \"frozen\" executables (i.e., " -"binaries produced by packages like **PyInstaller** and **cx_Freeze**) on Unix. The ``'fork'`` start method does " +"The ``'spawn'`` and ``'forkserver'`` start methods cannot currently be used " +"with \"frozen\" executables (i.e., binaries produced by packages like " +"**PyInstaller** and **cx_Freeze**) on Unix. The ``'fork'`` start method does " "work." msgstr "" -"Les méthodes de démarrage ``’spawn’`` et ``’forkserver’`` ne peuvent pas être utilisées avec des exécutables " -"« figés » (c'est-à-dire des binaires produits par des paquets comme **PyInstaller** et **cx_Freeze**) sur Unix. " +"Les méthodes de démarrage ``’spawn’`` et ``’forkserver’`` ne peuvent pas " +"être utilisées avec des exécutables « figés » (c'est-à-dire des binaires " +"produits par des paquets comme **PyInstaller** et **cx_Freeze**) sur Unix. " "Seule la méthode de démarrage ``’fork’`` fonctionne." #: library/multiprocessing.rst:209 @@ -250,20 +299,29 @@ msgid "Exchanging objects between processes" msgstr "Échange d'objets entre les processus" #: library/multiprocessing.rst:211 -msgid ":mod:`multiprocessing` supports two types of communication channel between processes:" -msgstr ":mod:`multiprocessing` gère deux types de canaux de communication entre les processus :" +msgid "" +":mod:`multiprocessing` supports two types of communication channel between " +"processes:" +msgstr "" +":mod:`multiprocessing` gère deux types de canaux de communication entre les " +"processus :" #: library/multiprocessing.rst:214 msgid "**Queues**" msgstr "**Files** (*queues*)" #: library/multiprocessing.rst:216 -msgid "The :class:`Queue` class is a near clone of :class:`queue.Queue`. For example::" -msgstr "La classe :class:`Queue` est un clone assez proche de :class:`queue.Queue`. Par exemple ::" +msgid "" +"The :class:`Queue` class is a near clone of :class:`queue.Queue`. For " +"example::" +msgstr "" +"La classe :class:`Queue` est un clone assez proche de :class:`queue.Queue`. " +"Par exemple ::" #: library/multiprocessing.rst:231 msgid "Queues are thread and process safe." -msgstr "Les files peuvent être utilisées par plusieurs fils d'exécution ou processus." +msgstr "" +"Les files peuvent être utilisées par plusieurs fils d'exécution ou processus." #: library/multiprocessing.rst:233 msgid "**Pipes**" @@ -271,24 +329,27 @@ msgstr "**Tubes** (*pipes*)" #: library/multiprocessing.rst:235 msgid "" -"The :func:`Pipe` function returns a pair of connection objects connected by a pipe which by default is duplex " -"(two-way). For example::" +"The :func:`Pipe` function returns a pair of connection objects connected by " +"a pipe which by default is duplex (two-way). For example::" msgstr "" -"La fonction :func:`Pipe` renvoie une paire d'objets de connexion connectés à un tube qui est par défaut duplex (à " -"double sens). Par exemple ::" +"La fonction :func:`Pipe` renvoie une paire d'objets de connexion connectés à " +"un tube qui est par défaut duplex (à double sens). Par exemple ::" #: library/multiprocessing.rst:251 msgid "" -"The two connection objects returned by :func:`Pipe` represent the two ends of the pipe. Each connection object " -"has :meth:`~Connection.send` and :meth:`~Connection.recv` methods (among others). Note that data in a pipe may " -"become corrupted if two processes (or threads) try to read from or write to the *same* end of the pipe at the " -"same time. Of course there is no risk of corruption from processes using different ends of the pipe at the same " -"time." -msgstr "" -"Les deux objets de connexion renvoyés par :func:`Pipe` représentent les deux bouts d'un tube. Chaque objet de " -"connexion possède (entre autres) des méthodes :meth:`~Connection.send` et :meth:`~Connection.recv`. Notez que les " -"données d'un tube peuvent être corrompues si deux processus (ou fils d'exécution) essaient de lire ou d'écrire " -"sur le même bout du tube en même temps. Évidemment il n'y a pas de risque de corruption si les processus " +"The two connection objects returned by :func:`Pipe` represent the two ends " +"of the pipe. Each connection object has :meth:`~Connection.send` and :meth:" +"`~Connection.recv` methods (among others). Note that data in a pipe may " +"become corrupted if two processes (or threads) try to read from or write to " +"the *same* end of the pipe at the same time. Of course there is no risk of " +"corruption from processes using different ends of the pipe at the same time." +msgstr "" +"Les deux objets de connexion renvoyés par :func:`Pipe` représentent les deux " +"bouts d'un tube. Chaque objet de connexion possède (entre autres) des " +"méthodes :meth:`~Connection.send` et :meth:`~Connection.recv`. Notez que les " +"données d'un tube peuvent être corrompues si deux processus (ou fils " +"d'exécution) essaient de lire ou d'écrire sur le même bout du tube en même " +"temps. Évidemment il n'y a pas de risque de corruption si les processus " "utilisent deux bouts différents en même temps." #: library/multiprocessing.rst:261 @@ -297,16 +358,22 @@ msgstr "Synchronisation entre processus" #: library/multiprocessing.rst:263 msgid "" -":mod:`multiprocessing` contains equivalents of all the synchronization primitives from :mod:`threading`. For " -"instance one can use a lock to ensure that only one process prints to standard output at a time::" +":mod:`multiprocessing` contains equivalents of all the synchronization " +"primitives from :mod:`threading`. For instance one can use a lock to ensure " +"that only one process prints to standard output at a time::" msgstr "" -":mod:`multiprocessing` contient des équivalents à toutes les primitives de synchronisation de :mod:`threading`. " -"Par exemple il est possible d'utiliser un verrou pour s'assurer qu'un seul processus à la fois écrit sur la " -"sortie standard ::" +":mod:`multiprocessing` contient des équivalents à toutes les primitives de " +"synchronisation de :mod:`threading`. Par exemple il est possible d'utiliser " +"un verrou pour s'assurer qu'un seul processus à la fois écrit sur la sortie " +"standard ::" #: library/multiprocessing.rst:282 -msgid "Without using the lock output from the different processes is liable to get all mixed up." -msgstr "Sans le verrou, les sorties des différents processus risquent d'être mélangées." +msgid "" +"Without using the lock output from the different processes is liable to get " +"all mixed up." +msgstr "" +"Sans le verrou, les sorties des différents processus risquent d'être " +"mélangées." #: library/multiprocessing.rst:287 msgid "Sharing state between processes" @@ -314,19 +381,21 @@ msgstr "Partager un état entre les processus" #: library/multiprocessing.rst:289 msgid "" -"As mentioned above, when doing concurrent programming it is usually best to avoid using shared state as far as " -"possible. This is particularly true when using multiple processes." +"As mentioned above, when doing concurrent programming it is usually best to " +"avoid using shared state as far as possible. This is particularly true when " +"using multiple processes." msgstr "" -"Comme mentionné plus haut, il est généralement préférable d'éviter autant que possible d'utiliser des états " -"partagés en programmation concurrente. C'est particulièrement vrai quand plusieurs processus sont utilisés." +"Comme mentionné plus haut, il est généralement préférable d'éviter autant " +"que possible d'utiliser des états partagés en programmation concurrente. " +"C'est particulièrement vrai quand plusieurs processus sont utilisés." #: library/multiprocessing.rst:293 msgid "" -"However, if you really do need to use some shared data then :mod:`multiprocessing` provides a couple of ways of " -"doing so." +"However, if you really do need to use some shared data then :mod:" +"`multiprocessing` provides a couple of ways of doing so." msgstr "" -"Cependant, si vous devez réellement partager des données, :mod:`multiprocessing` permet de le faire de deux " -"manières." +"Cependant, si vous devez réellement partager des données, :mod:" +"`multiprocessing` permet de le faire de deux manières." #: library/multiprocessing.rst:296 msgid "**Shared memory**" @@ -334,11 +403,11 @@ msgstr "**Mémoire partagée**" #: library/multiprocessing.rst:298 msgid "" -"Data can be stored in a shared memory map using :class:`Value` or :class:`Array`. For example, the following " -"code ::" +"Data can be stored in a shared memory map using :class:`Value` or :class:" +"`Array`. For example, the following code ::" msgstr "" -"Les données peuvent être stockées dans une mémoire partagée en utilisant des :class:`Value` ou des :class:" -"`Array`. Par exemple, le code suivant ::" +"Les données peuvent être stockées dans une mémoire partagée en utilisant " +"des :class:`Value` ou des :class:`Array`. Par exemple, le code suivant ::" #: library/multiprocessing.rst:319 library/multiprocessing.rst:365 msgid "will print ::" @@ -346,22 +415,26 @@ msgstr "affiche ::" #: library/multiprocessing.rst:324 msgid "" -"The ``'d'`` and ``'i'`` arguments used when creating ``num`` and ``arr`` are typecodes of the kind used by the :" -"mod:`array` module: ``'d'`` indicates a double precision float and ``'i'`` indicates a signed integer. These " -"shared objects will be process and thread-safe." +"The ``'d'`` and ``'i'`` arguments used when creating ``num`` and ``arr`` are " +"typecodes of the kind used by the :mod:`array` module: ``'d'`` indicates a " +"double precision float and ``'i'`` indicates a signed integer. These shared " +"objects will be process and thread-safe." msgstr "" -"Les arguments ``'d'`` et ``'i'`` utilisés à la création des ``num`` et ``arr`` sont des codes de types identiques " -"à ceux du module :mod:`array` : ``'d'`` indique un flottant double-précision et ``'i'`` indique un entier signé. " -"Ces objets peuvent être partagés sans problème entre processus ou fils d’exécution." +"Les arguments ``'d'`` et ``'i'`` utilisés à la création des ``num`` et " +"``arr`` sont des codes de types identiques à ceux du module :mod:`array` : " +"``'d'`` indique un flottant double-précision et ``'i'`` indique un entier " +"signé. Ces objets peuvent être partagés sans problème entre processus ou " +"fils d’exécution." #: library/multiprocessing.rst:329 msgid "" -"For more flexibility in using shared memory one can use the :mod:`multiprocessing.sharedctypes` module which " -"supports the creation of arbitrary ctypes objects allocated from shared memory." +"For more flexibility in using shared memory one can use the :mod:" +"`multiprocessing.sharedctypes` module which supports the creation of " +"arbitrary ctypes objects allocated from shared memory." msgstr "" -"Pour plus de flexibilité dans l'utilisation de mémoire partagée, vous pouvez utiliser le module :mod:" -"`multiprocessing.sharedctypes` qui permet la création d'objets arbitraires *ctypes* alloués depuis la mémoire " -"partagée." +"Pour plus de flexibilité dans l'utilisation de mémoire partagée, vous pouvez " +"utiliser le module :mod:`multiprocessing.sharedctypes` qui permet la " +"création d'objets arbitraires *ctypes* alloués depuis la mémoire partagée." #: library/multiprocessing.rst:333 msgid "**Server process**" @@ -369,31 +442,40 @@ msgstr "**Processus serveur**" #: library/multiprocessing.rst:335 msgid "" -"A manager object returned by :func:`Manager` controls a server process which holds Python objects and allows " -"other processes to manipulate them using proxies." +"A manager object returned by :func:`Manager` controls a server process which " +"holds Python objects and allows other processes to manipulate them using " +"proxies." msgstr "" -"Un objet gestionnaire renvoyé par :func:`Manager` contrôle un processus serveur qui détient les objets Python et " -"autorise les autres processus à les manipuler à l'aide de mandataires." +"Un objet gestionnaire renvoyé par :func:`Manager` contrôle un processus " +"serveur qui détient les objets Python et autorise les autres processus à les " +"manipuler à l'aide de mandataires." #: library/multiprocessing.rst:339 msgid "" -"A manager returned by :func:`Manager` will support types :class:`list`, :class:`dict`, :class:`~managers." -"Namespace`, :class:`Lock`, :class:`RLock`, :class:`Semaphore`, :class:`BoundedSemaphore`, :class:`Condition`, :" -"class:`Event`, :class:`Barrier`, :class:`Queue`, :class:`Value` and :class:`Array`. For example, ::" +"A manager returned by :func:`Manager` will support types :class:`list`, :" +"class:`dict`, :class:`~managers.Namespace`, :class:`Lock`, :class:`RLock`, :" +"class:`Semaphore`, :class:`BoundedSemaphore`, :class:`Condition`, :class:" +"`Event`, :class:`Barrier`, :class:`Queue`, :class:`Value` and :class:" +"`Array`. For example, ::" msgstr "" -"Un gestionnaire renvoyé par :func:`Manager` prend en charge les types :class:`list`, :class:`dict`, :class:" -"`~managers.Namespace`, :class:`Lock`, :class:`RLock`, :class:`Semaphore`, :class:`BoundedSemaphore`, :class:" -"`Condition`, :class:`Event`, :class:`Barrier`, :class:`Queue`, :class:`Value` et :class:`Array`. Par exemple, ::" +"Un gestionnaire renvoyé par :func:`Manager` prend en charge les types :class:" +"`list`, :class:`dict`, :class:`~managers.Namespace`, :class:`Lock`, :class:" +"`RLock`, :class:`Semaphore`, :class:`BoundedSemaphore`, :class:`Condition`, :" +"class:`Event`, :class:`Barrier`, :class:`Queue`, :class:`Value` et :class:" +"`Array`. Par exemple, ::" #: library/multiprocessing.rst:370 msgid "" -"Server process managers are more flexible than using shared memory objects because they can be made to support " -"arbitrary object types. Also, a single manager can be shared by processes on different computers over a network. " +"Server process managers are more flexible than using shared memory objects " +"because they can be made to support arbitrary object types. Also, a single " +"manager can be shared by processes on different computers over a network. " "They are, however, slower than using shared memory." msgstr "" -"Les processus serveurs de gestionnaires sont plus flexibles que les mémoires partagées parce qu'ils peuvent gérer " -"des types d'objets arbitraires. Aussi, un gestionnaire unique peut être partagé par les processus sur différentes " -"machines à travers le réseau. Cependant, ils sont plus lents que les mémoires partagées." +"Les processus serveurs de gestionnaires sont plus flexibles que les mémoires " +"partagées parce qu'ils peuvent gérer des types d'objets arbitraires. Aussi, " +"un gestionnaire unique peut être partagé par les processus sur différentes " +"machines à travers le réseau. Cependant, ils sont plus lents que les " +"mémoires partagées." #: library/multiprocessing.rst:377 msgid "Using a pool of workers" @@ -401,47 +483,61 @@ msgstr "Utiliser un pool de *workers*" #: library/multiprocessing.rst:379 msgid "" -"The :class:`~multiprocessing.pool.Pool` class represents a pool of worker processes. It has methods which allows " -"tasks to be offloaded to the worker processes in a few different ways." +"The :class:`~multiprocessing.pool.Pool` class represents a pool of worker " +"processes. It has methods which allows tasks to be offloaded to the worker " +"processes in a few different ways." msgstr "" -"La classe :class:`~multiprocessing.pool.Pool` représente un pool de processus de travail. Elle possède des " -"méthodes qui permettent aux tâches d'être déchargées vers les processus de travail de différentes manières." +"La classe :class:`~multiprocessing.pool.Pool` représente un pool de " +"processus de travail. Elle possède des méthodes qui permettent aux tâches " +"d'être déchargées vers les processus de travail de différentes manières." #: library/multiprocessing.rst:383 msgid "For example::" msgstr "Par exemple ::" #: library/multiprocessing.rst:427 -msgid "Note that the methods of a pool should only ever be used by the process which created it." -msgstr "Notez que les méthodes d'une pool ne doivent être utilisées que par le processus qui l'a créée." +msgid "" +"Note that the methods of a pool should only ever be used by the process " +"which created it." +msgstr "" +"Notez que les méthodes d'une pool ne doivent être utilisées que par le " +"processus qui l'a créée." #: library/multiprocessing.rst:432 msgid "" -"Functionality within this package requires that the ``__main__`` module be importable by the children. This is " -"covered in :ref:`multiprocessing-programming` however it is worth pointing out here. This means that some " -"examples, such as the :class:`multiprocessing.pool.Pool` examples will not work in the interactive interpreter. " -"For example::" +"Functionality within this package requires that the ``__main__`` module be " +"importable by the children. This is covered in :ref:`multiprocessing-" +"programming` however it is worth pointing out here. This means that some " +"examples, such as the :class:`multiprocessing.pool.Pool` examples will not " +"work in the interactive interpreter. For example::" msgstr "" -"Fonctionnellement ce paquet exige que que le module ``__main__`` soit importable par les fils. Cela est expliqué " -"sur la page :ref:`multiprocessing-programming`, il est cependant utile de le rappeler ici. Cela signifie que " -"certains exemples, comme les exemples utilisant :class:`multiprocessing.pool.Pool`, ne fonctionnent pas dans " -"l'interpréteur interactif. Par exemple ::" +"Fonctionnellement ce paquet exige que que le module ``__main__`` soit " +"importable par les fils. Cela est expliqué sur la page :ref:`multiprocessing-" +"programming`, il est cependant utile de le rappeler ici. Cela signifie que " +"certains exemples, comme les exemples utilisant :class:`multiprocessing.pool." +"Pool`, ne fonctionnent pas dans l'interpréteur interactif. Par exemple ::" #: library/multiprocessing.rst:455 msgid "" -"(If you try this it will actually output three full tracebacks interleaved in a semi-random fashion, and then you " -"may have to stop the parent process somehow.)" +"(If you try this it will actually output three full tracebacks interleaved " +"in a semi-random fashion, and then you may have to stop the parent process " +"somehow.)" msgstr "" -"Si vous essayez ce code, il affichera trois traces d'appels complètes entrelacées de manière semi-aléatoire, et " -"vous devrez vous débrouiller pour arrêter le processus maître." +"Si vous essayez ce code, il affichera trois traces d'appels complètes " +"entrelacées de manière semi-aléatoire, et vous devrez vous débrouiller pour " +"arrêter le processus maître." #: library/multiprocessing.rst:461 msgid "Reference" msgstr "Référence" #: library/multiprocessing.rst:463 -msgid "The :mod:`multiprocessing` package mostly replicates the API of the :mod:`threading` module." -msgstr "Le paquet :mod:`multiprocessing` reproduit en grande partie l'API du module :mod:`threading`." +msgid "" +"The :mod:`multiprocessing` package mostly replicates the API of the :mod:" +"`threading` module." +msgstr "" +"Le paquet :mod:`multiprocessing` reproduit en grande partie l'API du module :" +"mod:`threading`." #: library/multiprocessing.rst:468 msgid ":class:`Process` and exceptions" @@ -449,29 +545,37 @@ msgstr ":class:`Process` et exceptions" #: library/multiprocessing.rst:473 msgid "" -"Process objects represent activity that is run in a separate process. The :class:`Process` class has equivalents " -"of all the methods of :class:`threading.Thread`." +"Process objects represent activity that is run in a separate process. The :" +"class:`Process` class has equivalents of all the methods of :class:" +"`threading.Thread`." msgstr "" -"Les objets *process* représentent une activité exécutée dans un processus séparé. La classe :class:`Process` a " -"des équivalents à toutes les méthodes de :class:`threading.Thread`." +"Les objets *process* représentent une activité exécutée dans un processus " +"séparé. La classe :class:`Process` a des équivalents à toutes les méthodes " +"de :class:`threading.Thread`." #: library/multiprocessing.rst:477 msgid "" -"The constructor should always be called with keyword arguments. *group* should always be ``None``; it exists " -"solely for compatibility with :class:`threading.Thread`. *target* is the callable object to be invoked by the :" -"meth:`run()` method. It defaults to ``None``, meaning nothing is called. *name* is the process name (see :attr:" -"`name` for more details). *args* is the argument tuple for the target invocation. *kwargs* is a dictionary of " -"keyword arguments for the target invocation. If provided, the keyword-only *daemon* argument sets the process :" -"attr:`daemon` flag to ``True`` or ``False``. If ``None`` (the default), this flag will be inherited from the " +"The constructor should always be called with keyword arguments. *group* " +"should always be ``None``; it exists solely for compatibility with :class:" +"`threading.Thread`. *target* is the callable object to be invoked by the :" +"meth:`run()` method. It defaults to ``None``, meaning nothing is called. " +"*name* is the process name (see :attr:`name` for more details). *args* is " +"the argument tuple for the target invocation. *kwargs* is a dictionary of " +"keyword arguments for the target invocation. If provided, the keyword-only " +"*daemon* argument sets the process :attr:`daemon` flag to ``True`` or " +"``False``. If ``None`` (the default), this flag will be inherited from the " "creating process." msgstr "" -"Le constructeur doit toujours être appelé avec des arguments nommés. *group* doit toujours être ``None`` ; il " -"existe uniquement pour la compatibilité avec :class:`threading.Thread`. *target* est l'objet appelable qui est " -"invoqué par la méthode :meth:`run(). Il vaut ``None`` par défaut, signifiant que rien n'est appelé. *name* est le " -"nom du processus (voir :attr:`name` pour plus de détails). *args* est le *n*-uplet d'arguments pour l'invocation " -"de la cible. *kwargs* est le dictionnaire des arguments nommés pour l'invocation de la cible. S'il est fourni, " -"l'argument nommé *daemon* met l'option :attr:`daemon` du processus à ``True`` ou ``False``. S'il est ``None`` " -"(par défaut), l'option est héritée par le processus créateur." +"Le constructeur doit toujours être appelé avec des arguments nommés. *group* " +"doit toujours être ``None`` ; il existe uniquement pour la compatibilité " +"avec :class:`threading.Thread`. *target* est l'objet appelable qui est " +"invoqué par la méthode :meth:`run(). Il vaut ``None`` par défaut, signifiant " +"que rien n'est appelé. *name* est le nom du processus (voir :attr:`name` " +"pour plus de détails). *args* est le *n*-uplet d'arguments pour l'invocation " +"de la cible. *kwargs* est le dictionnaire des arguments nommés pour " +"l'invocation de la cible. S'il est fourni, l'argument nommé *daemon* met " +"l'option :attr:`daemon` du processus à ``True`` ou ``False``. S'il est " +"``None`` (par défaut), l'option est héritée par le processus créateur." #: library/multiprocessing.rst:488 msgid "By default, no arguments are passed to *target*." @@ -479,11 +583,13 @@ msgstr "Par défaut, aucun argument n'est passé à *target*." #: library/multiprocessing.rst:490 msgid "" -"If a subclass overrides the constructor, it must make sure it invokes the base class constructor (:meth:`Process." -"__init__`) before doing anything else to the process." +"If a subclass overrides the constructor, it must make sure it invokes the " +"base class constructor (:meth:`Process.__init__`) before doing anything else " +"to the process." msgstr "" -"Si une sous-classe redéfinit le constructeur, elle doit s'assurer d'invoquer le constructeur de la classe de base " -"(:meth:`Process.__init__`) avant de faire autre chose du processus." +"Si une sous-classe redéfinit le constructeur, elle doit s'assurer d'invoquer " +"le constructeur de la classe de base (:meth:`Process.__init__`) avant de " +"faire autre chose du processus." #: library/multiprocessing.rst:494 msgid "Added the *daemon* argument." @@ -495,12 +601,14 @@ msgstr "Méthode représentant l'activité du processus." #: library/multiprocessing.rst:501 msgid "" -"You may override this method in a subclass. The standard :meth:`run` method invokes the callable object passed " -"to the object's constructor as the target argument, if any, with sequential and keyword arguments taken from the " +"You may override this method in a subclass. The standard :meth:`run` method " +"invokes the callable object passed to the object's constructor as the target " +"argument, if any, with sequential and keyword arguments taken from the " "*args* and *kwargs* arguments, respectively." msgstr "" -"Vous pouvez redéfinir cette méthode dans une sous-classe. La méthode standard :meth:`run` invoque l'objet " -"appelable passé au constructeur comme argument *target*, si fourni, avec les arguments séquentiels et nommés " +"Vous pouvez redéfinir cette méthode dans une sous-classe. La méthode " +"standard :meth:`run` invoque l'objet appelable passé au constructeur comme " +"argument *target*, si fourni, avec les arguments séquentiels et nommés " "respectivement pris depuis les paramètres *args* et *kwargs*." #: library/multiprocessing.rst:508 @@ -509,23 +617,28 @@ msgstr "Démarre l'activité du processus." #: library/multiprocessing.rst:510 msgid "" -"This must be called at most once per process object. It arranges for the object's :meth:`run` method to be " -"invoked in a separate process." +"This must be called at most once per process object. It arranges for the " +"object's :meth:`run` method to be invoked in a separate process." msgstr "" -"Elle doit être appelée au plus une fois par objet processus. Elle s'arrange pour que la méthode :meth:`run` de " -"l'objet soit invoquée dans un processus séparé." +"Elle doit être appelée au plus une fois par objet processus. Elle s'arrange " +"pour que la méthode :meth:`run` de l'objet soit invoquée dans un processus " +"séparé." #: library/multiprocessing.rst:515 msgid "" -"If the optional argument *timeout* is ``None`` (the default), the method blocks until the process whose :meth:" -"`join` method is called terminates. If *timeout* is a positive number, it blocks at most *timeout* seconds. Note " -"that the method returns ``None`` if its process terminates or if the method times out. Check the process's :attr:" -"`exitcode` to determine if it terminated." +"If the optional argument *timeout* is ``None`` (the default), the method " +"blocks until the process whose :meth:`join` method is called terminates. If " +"*timeout* is a positive number, it blocks at most *timeout* seconds. Note " +"that the method returns ``None`` if its process terminates or if the method " +"times out. Check the process's :attr:`exitcode` to determine if it " +"terminated." msgstr "" -"Si l'argument optionnel *timeout* est ``None`` (par défaut), la méthode bloque jusqu'à ce que le processus dont " -"la méthode :meth:`join` a été appelée se termine. Si *timeout* est un nombre positif, elle bloque au maximum " -"pendant *timeout* secondes. Notez que la méthode renvoie ``None`` si le processus se termine ou si le temps " -"d'exécution expire. Vérifiez l'attribut :attr:`exitcode` du processus pour déterminer s'il s'est terminé." +"Si l'argument optionnel *timeout* est ``None`` (par défaut), la méthode " +"bloque jusqu'à ce que le processus dont la méthode :meth:`join` a été " +"appelée se termine. Si *timeout* est un nombre positif, elle bloque au " +"maximum pendant *timeout* secondes. Notez que la méthode renvoie ``None`` si " +"le processus se termine ou si le temps d'exécution expire. Vérifiez " +"l'attribut :attr:`exitcode` du processus pour déterminer s'il s'est terminé." #: library/multiprocessing.rst:522 msgid "A process can be joined many times." @@ -533,28 +646,32 @@ msgstr "*join* peut être appelée plusieurs fois sur un même processus." #: library/multiprocessing.rst:524 msgid "" -"A process cannot join itself because this would cause a deadlock. It is an error to attempt to join a process " -"before it has been started." +"A process cannot join itself because this would cause a deadlock. It is an " +"error to attempt to join a process before it has been started." msgstr "" -"Un processus ne peut pas s'attendre lui-même car cela causerait un interblocage. C'est une erreur d'essayer " -"d'attendre un processus avant qu'il ne soit démarré." +"Un processus ne peut pas s'attendre lui-même car cela causerait un " +"interblocage. C'est une erreur d'essayer d'attendre un processus avant qu'il " +"ne soit démarré." #: library/multiprocessing.rst:529 msgid "" -"The process's name. The name is a string used for identification purposes only. It has no semantics. Multiple " -"processes may be given the same name." +"The process's name. The name is a string used for identification purposes " +"only. It has no semantics. Multiple processes may be given the same name." msgstr "" -"Le nom du processus. Le nom est une chaîne de caractères utilisée uniquement pour l'identification du processus. " -"Il n'a pas de sémantique. Plusieurs processus peuvent avoir le même nom." +"Le nom du processus. Le nom est une chaîne de caractères utilisée uniquement " +"pour l'identification du processus. Il n'a pas de sémantique. Plusieurs " +"processus peuvent avoir le même nom." #: library/multiprocessing.rst:533 msgid "" -"The initial name is set by the constructor. If no explicit name is provided to the constructor, a name of the " -"form 'Process-N\\ :sub:`1`:N\\ :sub:`2`:...:N\\ :sub:`k`' is constructed, where each N\\ :sub:`k` is the N-th " +"The initial name is set by the constructor. If no explicit name is provided " +"to the constructor, a name of the form 'Process-N\\ :sub:`1`:N\\ :sub:" +"`2`:...:N\\ :sub:`k`' is constructed, where each N\\ :sub:`k` is the N-th " "child of its parent." msgstr "" -"Le nom initial est déterminé par le constructeur. Si aucun nom explicite n'est fourni au constructeur, un nom de " -"la forme « Process-N\\ :sub:`1`:N\\ :sub:`2`:...:N\\ :sub:`k` » est construit, où chaque N\\ :sub:`k` est le N\\ :" +"Le nom initial est déterminé par le constructeur. Si aucun nom explicite " +"n'est fourni au constructeur, un nom de la forme « Process-N\\ :sub:`1`:N\\ :" +"sub:`2`:...:N\\ :sub:`k` » est construit, où chaque N\\ :sub:`k` est le N\\ :" "sup:`e` enfant de son parent." #: library/multiprocessing.rst:540 @@ -563,57 +680,70 @@ msgstr "Renvoie vrai si le processus est en vie, faux sinon." #: library/multiprocessing.rst:542 msgid "" -"Roughly, a process object is alive from the moment the :meth:`start` method returns until the child process " -"terminates." +"Roughly, a process object is alive from the moment the :meth:`start` method " +"returns until the child process terminates." msgstr "" -"Grossièrement, un objet processus est en vie depuis le moment où la méthode :meth:`start` finit de s'exécuter " -"jusqu'à ce que le processus fils se termine." +"Grossièrement, un objet processus est en vie depuis le moment où la méthode :" +"meth:`start` finit de s'exécuter jusqu'à ce que le processus fils se termine." #: library/multiprocessing.rst:547 -msgid "The process's daemon flag, a Boolean value. This must be set before :meth:`start` is called." +msgid "" +"The process's daemon flag, a Boolean value. This must be set before :meth:" +"`start` is called." msgstr "" -"L'option *daemon* du processus, une valeur booléenne. L'option doit être réglée avant que la méthode :meth:" -"`start` ne soit appelée." +"L'option *daemon* du processus, une valeur booléenne. L'option doit être " +"réglée avant que la méthode :meth:`start` ne soit appelée." #: library/multiprocessing.rst:550 msgid "The initial value is inherited from the creating process." msgstr "La valeur initiale est héritée par le processus créateur." #: library/multiprocessing.rst:552 -msgid "When a process exits, it attempts to terminate all of its daemonic child processes." -msgstr "Quand un processus se ferme, il tente de terminer tous ses processus enfants *daemon*." +msgid "" +"When a process exits, it attempts to terminate all of its daemonic child " +"processes." +msgstr "" +"Quand un processus se ferme, il tente de terminer tous ses processus enfants " +"*daemon*." #: library/multiprocessing.rst:555 msgid "" -"Note that a daemonic process is not allowed to create child processes. Otherwise a daemonic process would leave " -"its children orphaned if it gets terminated when its parent process exits. Additionally, these are **not** Unix " -"daemons or services, they are normal processes that will be terminated (and not joined) if non-daemonic processes " -"have exited." +"Note that a daemonic process is not allowed to create child processes. " +"Otherwise a daemonic process would leave its children orphaned if it gets " +"terminated when its parent process exits. Additionally, these are **not** " +"Unix daemons or services, they are normal processes that will be terminated " +"(and not joined) if non-daemonic processes have exited." msgstr "" -"Notez qu'un processus *daemon* n'est pas autorisé à créer des processus fils. Sinon un processus *daemon* " -"laisserait ses enfants orphelins lorsqu'il se termine par la fermeture de son parent. De plus, ce **ne sont pas** " -"des *daemons* ou services Unix, ce sont des processus normaux qui seront terminés (et non attendus) si un " -"processus non *daemon* se ferme." +"Notez qu'un processus *daemon* n'est pas autorisé à créer des processus " +"fils. Sinon un processus *daemon* laisserait ses enfants orphelins lorsqu'il " +"se termine par la fermeture de son parent. De plus, ce **ne sont pas** des " +"*daemons* ou services Unix, ce sont des processus normaux qui seront " +"terminés (et non attendus) si un processus non *daemon* se ferme." #: library/multiprocessing.rst:561 msgid "" -"In addition to the :class:`threading.Thread` API, :class:`Process` objects also support the following attributes " -"and methods:" +"In addition to the :class:`threading.Thread` API, :class:`Process` objects " +"also support the following attributes and methods:" msgstr "" -"En plus de l'API :class:`threading.Thread`, les objets :class:`Process` supportent aussi les attributs et " -"méthodes suivants :" +"En plus de l'API :class:`threading.Thread`, les objets :class:`Process` " +"supportent aussi les attributs et méthodes suivants :" #: library/multiprocessing.rst:566 -msgid "Return the process ID. Before the process is spawned, this will be ``None``." -msgstr "Renvoie l'ID du processus. Avant que le processus ne soit lancé, la valeur est ``None``." +msgid "" +"Return the process ID. Before the process is spawned, this will be ``None``." +msgstr "" +"Renvoie l'ID du processus. Avant que le processus ne soit lancé, la valeur " +"est ``None``." #: library/multiprocessing.rst:571 msgid "" -"The child's exit code. This will be ``None`` if the process has not yet terminated. A negative value *-N* " -"indicates that the child was terminated by signal *N*." +"The child's exit code. This will be ``None`` if the process has not yet " +"terminated. A negative value *-N* indicates that the child was terminated " +"by signal *N*." msgstr "" -"Le code de retour du fils. La valeur est ``None`` si le processus ne s'est pas encore terminé. Une valeur " -"négative *-N* indique que le fils a été terminé par un signal *N*." +"Le code de retour du fils. La valeur est ``None`` si le processus ne s'est " +"pas encore terminé. Une valeur négative *-N* indique que le fils a été " +"terminé par un signal *N*." #: library/multiprocessing.rst:577 msgid "The process's authentication key (a byte string)." @@ -621,89 +751,116 @@ msgstr "La clé d'authentification du processus (une chaîne d'octets)." #: library/multiprocessing.rst:579 msgid "" -"When :mod:`multiprocessing` is initialized the main process is assigned a random string using :func:`os.urandom`." +"When :mod:`multiprocessing` is initialized the main process is assigned a " +"random string using :func:`os.urandom`." msgstr "" -"Quand :mod:`multiprocessing` est initialisé, une chaîne aléatoire est assignée au processus principal, en " -"utilisant :func:`os.urandom`." +"Quand :mod:`multiprocessing` est initialisé, une chaîne aléatoire est " +"assignée au processus principal, en utilisant :func:`os.urandom`." #: library/multiprocessing.rst:582 msgid "" -"When a :class:`Process` object is created, it will inherit the authentication key of its parent process, although " -"this may be changed by setting :attr:`authkey` to another byte string." +"When a :class:`Process` object is created, it will inherit the " +"authentication key of its parent process, although this may be changed by " +"setting :attr:`authkey` to another byte string." msgstr "" -"Quand un objet :class:`Process` est créé, il hérité de la clé d'authentification de son parent, bien que cela " -"puisse être changé à l'aide du paramètre :attr:`authkey` pour une autre chaîne d'octets." +"Quand un objet :class:`Process` est créé, il hérité de la clé " +"d'authentification de son parent, bien que cela puisse être changé à l'aide " +"du paramètre :attr:`authkey` pour une autre chaîne d'octets." #: library/multiprocessing.rst:586 msgid "See :ref:`multiprocessing-auth-keys`." msgstr "Voir :ref:`multiprocessing-auth-keys`." #: library/multiprocessing.rst:590 -msgid "A numeric handle of a system object which will become \"ready\" when the process ends." -msgstr "Un identifiant numérique de l'objet système qui devient « prêt » quand le processus se termine." +msgid "" +"A numeric handle of a system object which will become \"ready\" when the " +"process ends." +msgstr "" +"Un identifiant numérique de l'objet système qui devient « prêt » quand le " +"processus se termine." #: library/multiprocessing.rst:593 msgid "" -"You can use this value if you want to wait on several events at once using :func:`multiprocessing.connection." -"wait`. Otherwise calling :meth:`join()` is simpler." +"You can use this value if you want to wait on several events at once using :" +"func:`multiprocessing.connection.wait`. Otherwise calling :meth:`join()` is " +"simpler." msgstr "" -"Vous pouvez utiliser cette valeur si vous voulez attendre plusieurs événements à la fois en utilisant :func:" -"`multiprocessing.connection.wait`. Autrement appeler :meth:`join()` est plus simple." +"Vous pouvez utiliser cette valeur si vous voulez attendre plusieurs " +"événements à la fois en utilisant :func:`multiprocessing.connection.wait`. " +"Autrement appeler :meth:`join()` est plus simple." #: library/multiprocessing.rst:597 msgid "" -"On Windows, this is an OS handle usable with the ``WaitForSingleObject`` and ``WaitForMultipleObjects`` family of " -"API calls. On Unix, this is a file descriptor usable with primitives from the :mod:`select` module." +"On Windows, this is an OS handle usable with the ``WaitForSingleObject`` and " +"``WaitForMultipleObjects`` family of API calls. On Unix, this is a file " +"descriptor usable with primitives from the :mod:`select` module." msgstr "" -"Sous Windows, c'est un mécanisme système utilisable avec les familles d'appels API ``WaitForSingleObject`` et " -"``WaitForMultipleObjects``. Sous Unix, c'est un descripteur de fichier utilisable avec les primitives sur module :" -"mod:`select`." +"Sous Windows, c'est un mécanisme système utilisable avec les familles " +"d'appels API ``WaitForSingleObject`` et ``WaitForMultipleObjects``. Sous " +"Unix, c'est un descripteur de fichier utilisable avec les primitives sur " +"module :mod:`select`." #: library/multiprocessing.rst:605 msgid "" -"Terminate the process. On Unix this is done using the ``SIGTERM`` signal; on Windows :c:func:`TerminateProcess` " -"is used. Note that exit handlers and finally clauses, etc., will not be executed." +"Terminate the process. On Unix this is done using the ``SIGTERM`` signal; " +"on Windows :c:func:`TerminateProcess` is used. Note that exit handlers and " +"finally clauses, etc., will not be executed." msgstr "" -"Termine le processus. Sous Unix cela est réalisé à l'aide d'un signal ``SIGTERM``, sous Windows :c:func:" -"`TerminateProcess` est utilisé. Notez que les gestionnaires de sortie, les clauses `finally` etc. ne sont pas " +"Termine le processus. Sous Unix cela est réalisé à l'aide d'un signal " +"``SIGTERM``, sous Windows :c:func:`TerminateProcess` est utilisé. Notez que " +"les gestionnaires de sortie, les clauses `finally` etc. ne sont pas " "exécutées." #: library/multiprocessing.rst:609 -msgid "Note that descendant processes of the process will *not* be terminated -- they will simply become orphaned." -msgstr "Notez que les descendants du processus ne sont *pas* terminés – ils deviendront simplement orphelins." +msgid "" +"Note that descendant processes of the process will *not* be terminated -- " +"they will simply become orphaned." +msgstr "" +"Notez que les descendants du processus ne sont *pas* terminés – ils " +"deviendront simplement orphelins." #: library/multiprocessing.rst:614 msgid "" -"If this method is used when the associated process is using a pipe or queue then the pipe or queue is liable to " -"become corrupted and may become unusable by other process. Similarly, if the process has acquired a lock or " -"semaphore etc. then terminating it is liable to cause other processes to deadlock." +"If this method is used when the associated process is using a pipe or queue " +"then the pipe or queue is liable to become corrupted and may become unusable " +"by other process. Similarly, if the process has acquired a lock or " +"semaphore etc. then terminating it is liable to cause other processes to " +"deadlock." msgstr "" -"Si cette méthode est utilisée quand le processus associé utilise un tube ou une file, alors le tube ou la file" -"sont susceptibles d'être corrompus et peuvent devenir inutilisables par les autres processus. De façon similaire, " -"si le processus a acquis un verrou, un sémaphore ou autre, alors le terminer est susceptible de provoquer des " -"blocages dans les autres processus." +"Si cette méthode est utilisée quand le processus associé utilise un tube ou " +"une file, alors le tube ou la filesont susceptibles d'être corrompus et " +"peuvent devenir inutilisables par les autres processus. De façon similaire, " +"si le processus a acquis un verrou, un sémaphore ou autre, alors le terminer " +"est susceptible de provoquer des blocages dans les autres processus." #: library/multiprocessing.rst:622 msgid "Same as :meth:`terminate()` but using the ``SIGKILL`` signal on Unix." -msgstr "Identique à :meth:`terminate()` mais utilisant le signal ``SIGKILL`` sous Unix." +msgstr "" +"Identique à :meth:`terminate()` mais utilisant le signal ``SIGKILL`` sous " +"Unix." #: library/multiprocessing.rst:628 msgid "" -"Close the :class:`Process` object, releasing all resources associated with it. :exc:`ValueError` is raised if " -"the underlying process is still running. Once :meth:`close` returns successfully, most other methods and " +"Close the :class:`Process` object, releasing all resources associated with " +"it. :exc:`ValueError` is raised if the underlying process is still " +"running. Once :meth:`close` returns successfully, most other methods and " "attributes of the :class:`Process` object will raise :exc:`ValueError`." msgstr "" -"Ferme l'objet :class:`Process`, libérant toutes les ressources qui lui sont associées. Une :exc:`ValueError` est " -"levée si le processus sous-jacent tourne toujours. Une fois que :meth:`close` se termine avec succès, la plupart " -"des autres méthodes et attributs des objets :class:`Process` lèveront une :exc:`ValueError`." +"Ferme l'objet :class:`Process`, libérant toutes les ressources qui lui sont " +"associées. Une :exc:`ValueError` est levée si le processus sous-jacent " +"tourne toujours. Une fois que :meth:`close` se termine avec succès, la " +"plupart des autres méthodes et attributs des objets :class:`Process` " +"lèveront une :exc:`ValueError`." #: library/multiprocessing.rst:636 msgid "" -"Note that the :meth:`start`, :meth:`join`, :meth:`is_alive`, :meth:`terminate` and :attr:`exitcode` methods " -"should only be called by the process that created the process object." +"Note that the :meth:`start`, :meth:`join`, :meth:`is_alive`, :meth:" +"`terminate` and :attr:`exitcode` methods should only be called by the " +"process that created the process object." msgstr "" -"Notez que les méthodes :meth:`start`, :meth:`join`, :meth:`is_alive`, :meth:`terminate` et :attr:`exitcode` ne " -"doivent être appelées que par le processus ayant créé l'objet *process*." +"Notez que les méthodes :meth:`start`, :meth:`join`, :meth:`is_alive`, :meth:" +"`terminate` et :attr:`exitcode` ne doivent être appelées que par le " +"processus ayant créé l'objet *process*." #: library/multiprocessing.rst:640 msgid "Example usage of some of the methods of :class:`Process`:" @@ -715,17 +872,19 @@ msgstr "La classe de base de toutes les exceptions de :mod:`multiprocessing`." #: library/multiprocessing.rst:665 msgid "" -"Exception raised by :meth:`Connection.recv_bytes_into()` when the supplied buffer object is too small for the " -"message read." +"Exception raised by :meth:`Connection.recv_bytes_into()` when the supplied " +"buffer object is too small for the message read." msgstr "" -"Exception levée par :meth:`Connection.recv_bytes_into()` quand l'objet tampon fourni est trop petit pour le " -"message à lire." +"Exception levée par :meth:`Connection.recv_bytes_into()` quand l'objet " +"tampon fourni est trop petit pour le message à lire." #: library/multiprocessing.rst:668 -msgid "If ``e`` is an instance of :exc:`BufferTooShort` then ``e.args[0]`` will give the message as a byte string." +msgid "" +"If ``e`` is an instance of :exc:`BufferTooShort` then ``e.args[0]`` will " +"give the message as a byte string." msgstr "" -"Si ``e`` est une instance de :exc:`BufferTooShort` alors ``e.args[0]`` donnera un message sous forme d'une chaîne " -"d'octets." +"Si ``e`` est une instance de :exc:`BufferTooShort` alors ``e.args[0]`` " +"donnera un message sous forme d'une chaîne d'octets." #: library/multiprocessing.rst:673 msgid "Raised when there is an authentication error." @@ -733,7 +892,8 @@ msgstr "Levée quand il y a une erreur d'authentification." #: library/multiprocessing.rst:677 msgid "Raised by methods with a timeout when the timeout expires." -msgstr "Levée par les méthodes avec temps d'exécution limité, quand ce temps expire." +msgstr "" +"Levée par les méthodes avec temps d'exécution limité, quand ce temps expire." #: library/multiprocessing.rst:680 msgid "Pipes and Queues" @@ -741,225 +901,272 @@ msgstr "Tubes (*pipes*) et files (*queues*)" #: library/multiprocessing.rst:682 msgid "" -"When using multiple processes, one generally uses message passing for communication between processes and avoids " -"having to use any synchronization primitives like locks." +"When using multiple processes, one generally uses message passing for " +"communication between processes and avoids having to use any synchronization " +"primitives like locks." msgstr "" -"Quand de plusieurs processus travaillent ensemble, il est souvent nécessaire de les faire communiquer entre eux " -"pour éviter d'avoir à utiliser des primitives de synchronisation comme les verrous." +"Quand de plusieurs processus travaillent ensemble, il est souvent nécessaire " +"de les faire communiquer entre eux pour éviter d'avoir à utiliser des " +"primitives de synchronisation comme les verrous." #: library/multiprocessing.rst:686 msgid "" -"For passing messages one can use :func:`Pipe` (for a connection between two processes) or a queue (which allows " -"multiple producers and consumers)." +"For passing messages one can use :func:`Pipe` (for a connection between two " +"processes) or a queue (which allows multiple producers and consumers)." msgstr "" -"Pour échanger des messages vous pouvez utiliser un :func:`Pipe` (pour une connexion entre deux processus) ou une " -"file (qui autorise de plusieurs producteurs et consommateurs)." +"Pour échanger des messages vous pouvez utiliser un :func:`Pipe` (pour une " +"connexion entre deux processus) ou une file (qui autorise de plusieurs " +"producteurs et consommateurs)." #: library/multiprocessing.rst:689 msgid "" -"The :class:`Queue`, :class:`SimpleQueue` and :class:`JoinableQueue` types are multi-producer, multi-consumer :" -"abbr:`FIFO (first-in, first-out)` queues modelled on the :class:`queue.Queue` class in the standard library. " -"They differ in that :class:`Queue` lacks the :meth:`~queue.Queue.task_done` and :meth:`~queue.Queue.join` methods " -"introduced into Python 2.5's :class:`queue.Queue` class." +"The :class:`Queue`, :class:`SimpleQueue` and :class:`JoinableQueue` types " +"are multi-producer, multi-consumer :abbr:`FIFO (first-in, first-out)` queues " +"modelled on the :class:`queue.Queue` class in the standard library. They " +"differ in that :class:`Queue` lacks the :meth:`~queue.Queue.task_done` and :" +"meth:`~queue.Queue.join` methods introduced into Python 2.5's :class:`queue." +"Queue` class." msgstr "" -"Les types :class:`Queue`, :class:`SimpleQueue` et :class:`JoinableQueue` sont des files :abbr:`FIFO (first-in, " -"first-out)` multi-producteurs et multi-consommateurs modelées sur la classe :class:`queue.Queue` de la " -"bibliothèque standard. Elles diffèrent par l'absence dans :class:`Queue` des méthodes :meth:`~queue.Queue." -"task_done` et :meth:`~queue.Queue.join` introduites dans la classe :class:`queue.Queue` par Python 2.5." +"Les types :class:`Queue`, :class:`SimpleQueue` et :class:`JoinableQueue` " +"sont des files :abbr:`FIFO (first-in, first-out)` multi-producteurs et multi-" +"consommateurs modelées sur la classe :class:`queue.Queue` de la bibliothèque " +"standard. Elles diffèrent par l'absence dans :class:`Queue` des méthodes :" +"meth:`~queue.Queue.task_done` et :meth:`~queue.Queue.join` introduites dans " +"la classe :class:`queue.Queue` par Python 2.5." #: library/multiprocessing.rst:696 msgid "" -"If you use :class:`JoinableQueue` then you **must** call :meth:`JoinableQueue.task_done` for each task removed " -"from the queue or else the semaphore used to count the number of unfinished tasks may eventually overflow, " -"raising an exception." +"If you use :class:`JoinableQueue` then you **must** call :meth:" +"`JoinableQueue.task_done` for each task removed from the queue or else the " +"semaphore used to count the number of unfinished tasks may eventually " +"overflow, raising an exception." msgstr "" -"Si vous utilisez :class:`JoinableQueue` alors vous **devez** appeler :meth:`JoinableQueue.task_done` pour chaque " -"tâche retirée de la file, sans quoi le sémaphore utilisé pour compter le nombre de tâches non accomplies pourra " +"Si vous utilisez :class:`JoinableQueue` alors vous **devez** appeler :meth:" +"`JoinableQueue.task_done` pour chaque tâche retirée de la file, sans quoi le " +"sémaphore utilisé pour compter le nombre de tâches non accomplies pourra " "éventuellement déborder, levant une exception." #: library/multiprocessing.rst:701 msgid "" -"Note that one can also create a shared queue by using a manager object -- see :ref:`multiprocessing-managers`." +"Note that one can also create a shared queue by using a manager object -- " +"see :ref:`multiprocessing-managers`." msgstr "" -"Notez que vous pouvez aussi créer une file partagée en utilisant un objet gestionnaire – voir :ref:" -"`multiprocessing-managers`." +"Notez que vous pouvez aussi créer une file partagée en utilisant un objet " +"gestionnaire – voir :ref:`multiprocessing-managers`." #: library/multiprocessing.rst:706 msgid "" -":mod:`multiprocessing` uses the usual :exc:`queue.Empty` and :exc:`queue.Full` exceptions to signal a timeout. " -"They are not available in the :mod:`multiprocessing` namespace so you need to import them from :mod:`queue`." +":mod:`multiprocessing` uses the usual :exc:`queue.Empty` and :exc:`queue." +"Full` exceptions to signal a timeout. They are not available in the :mod:" +"`multiprocessing` namespace so you need to import them from :mod:`queue`." msgstr "" -":mod:`multiprocessing` utilise les exceptions habituelles :exc:`queue.Empty` et :exc:`queue.Full` pour signaler " -"un dépassement du temps maximal autorisé. Elles ne sont pas disponibles dans l'espace de nommage :mod:" +":mod:`multiprocessing` utilise les exceptions habituelles :exc:`queue.Empty` " +"et :exc:`queue.Full` pour signaler un dépassement du temps maximal autorisé. " +"Elles ne sont pas disponibles dans l'espace de nommage :mod:" "`multiprocessing` donc vous devez les importer depuis le module :mod:`queue`." #: library/multiprocessing.rst:713 msgid "" -"When an object is put on a queue, the object is pickled and a background thread later flushes the pickled data to " -"an underlying pipe. This has some consequences which are a little surprising, but should not cause any practical " -"difficulties -- if they really bother you then you can instead use a queue created with a :ref:`manager " -"`." +"When an object is put on a queue, the object is pickled and a background " +"thread later flushes the pickled data to an underlying pipe. This has some " +"consequences which are a little surprising, but should not cause any " +"practical difficulties -- if they really bother you then you can instead use " +"a queue created with a :ref:`manager `." msgstr "" -"Quand un objet est placé dans une file, l'objet est sérialisé par *pickle* et un fil d'exécution en arrière-plan " -"transmettra ensuite les données sérialisées sur un tube sous-jacent. Cela a certaines conséquences qui peuvent " -"être un peu surprenantes, mais ne devrait causer aucune difficulté pratique — si elles vous embêtent vraiment, " -"alors vous pouvez à la place utiliser une file créée avec un :ref:`manager `." +"Quand un objet est placé dans une file, l'objet est sérialisé par *pickle* " +"et un fil d'exécution en arrière-plan transmettra ensuite les données " +"sérialisées sur un tube sous-jacent. Cela a certaines conséquences qui " +"peuvent être un peu surprenantes, mais ne devrait causer aucune difficulté " +"pratique — si elles vous embêtent vraiment, alors vous pouvez à la place " +"utiliser une file créée avec un :ref:`manager `." #: library/multiprocessing.rst:720 msgid "" -"After putting an object on an empty queue there may be an infinitesimal delay before the queue's :meth:`~Queue." -"empty` method returns :const:`False` and :meth:`~Queue.get_nowait` can return without raising :exc:`queue.Empty`." +"After putting an object on an empty queue there may be an infinitesimal " +"delay before the queue's :meth:`~Queue.empty` method returns :const:`False` " +"and :meth:`~Queue.get_nowait` can return without raising :exc:`queue.Empty`." msgstr "" -"Après avoir placé un objet dans une file vide il peut y avoir un délai infinitésimal avant que la méthode :meth:" -"`~Queue.empty` de la file renvoie :const:`False` et que :meth:`~Queue.get_nowait` renvoie une valeur sans lever " +"Après avoir placé un objet dans une file vide il peut y avoir un délai " +"infinitésimal avant que la méthode :meth:`~Queue.empty` de la file renvoie :" +"const:`False` et que :meth:`~Queue.get_nowait` renvoie une valeur sans lever " "de :exc:`queue.Empty`." #: library/multiprocessing.rst:725 msgid "" -"If multiple processes are enqueuing objects, it is possible for the objects to be received at the other end out-" -"of-order. However, objects enqueued by the same process will always be in the expected order with respect to each " +"If multiple processes are enqueuing objects, it is possible for the objects " +"to be received at the other end out-of-order. However, objects enqueued by " +"the same process will always be in the expected order with respect to each " "other." msgstr "" -"Si plusieurs processus placent des objets dans la file, il est possible pour les objets d'être reçus de l'autre " -"côté dans le désordre. Cependant, les objets placés par un même processus seront toujours récupérés dans l'ordre " +"Si plusieurs processus placent des objets dans la file, il est possible pour " +"les objets d'être reçus de l'autre côté dans le désordre. Cependant, les " +"objets placés par un même processus seront toujours récupérés dans l'ordre " "d'insertion." #: library/multiprocessing.rst:732 msgid "" -"If a process is killed using :meth:`Process.terminate` or :func:`os.kill` while it is trying to use a :class:" -"`Queue`, then the data in the queue is likely to become corrupted. This may cause any other process to get an " +"If a process is killed using :meth:`Process.terminate` or :func:`os.kill` " +"while it is trying to use a :class:`Queue`, then the data in the queue is " +"likely to become corrupted. This may cause any other process to get an " "exception when it tries to use the queue later on." msgstr "" -"Si un processus est tué à l'aide de :meth:`Process.terminate` ou :func:`os.kill` pendant qu'il tente d'utiliser " -"une :class:`Queue`, alors les données de la file peuvent être corrompues. Cela peut par la suite causer des " -"levées d'exceptions dans les autres processus quand ils tenteront d'utiliser la file." +"Si un processus est tué à l'aide de :meth:`Process.terminate` ou :func:`os." +"kill` pendant qu'il tente d'utiliser une :class:`Queue`, alors les données " +"de la file peuvent être corrompues. Cela peut par la suite causer des levées " +"d'exceptions dans les autres processus quand ils tenteront d'utiliser la " +"file." #: library/multiprocessing.rst:739 msgid "" -"As mentioned above, if a child process has put items on a queue (and it has not used :meth:`JoinableQueue." -"cancel_join_thread `), then that process will not terminate until all " +"As mentioned above, if a child process has put items on a queue (and it has " +"not used :meth:`JoinableQueue.cancel_join_thread `), then that process will not terminate until all " "buffered items have been flushed to the pipe." msgstr "" -"Comme mentionné plus haut, si un processus fils a placé des éléments dans la file (et qu'il n'a pas utilisé :meth:" -"`JoinableQueue.cancel_join_thread `), alors le processus ne se " -"terminera pas tant que les éléments placés dans le tampon n'auront pas été transmis au tube." +"Comme mentionné plus haut, si un processus fils a placé des éléments dans la " +"file (et qu'il n'a pas utilisé :meth:`JoinableQueue.cancel_join_thread " +"`), alors le processus ne se " +"terminera pas tant que les éléments placés dans le tampon n'auront pas été " +"transmis au tube." #: library/multiprocessing.rst:744 msgid "" -"This means that if you try joining that process you may get a deadlock unless you are sure that all items which " -"have been put on the queue have been consumed. Similarly, if the child process is non-daemonic then the parent " -"process may hang on exit when it tries to join all its non-daemonic children." +"This means that if you try joining that process you may get a deadlock " +"unless you are sure that all items which have been put on the queue have " +"been consumed. Similarly, if the child process is non-daemonic then the " +"parent process may hang on exit when it tries to join all its non-daemonic " +"children." msgstr "" -"Cela signifie que si vous essayez d'attendre ce processus vous pouvez obtenir un interblocage, à moins que vous " -"ne soyez sûr que tous les éléments placés dans la file ont été consommés. De même, si le processus fils n'est pas " -"un *daemon* alors le processus parent pourrait bloquer à la fermeture quand il tentera d'attendre tous ses " -"enfants non *daemons*." +"Cela signifie que si vous essayez d'attendre ce processus vous pouvez " +"obtenir un interblocage, à moins que vous ne soyez sûr que tous les éléments " +"placés dans la file ont été consommés. De même, si le processus fils n'est " +"pas un *daemon* alors le processus parent pourrait bloquer à la fermeture " +"quand il tentera d'attendre tous ses enfants non *daemons*." #: library/multiprocessing.rst:749 -msgid "Note that a queue created using a manager does not have this issue. See :ref:`multiprocessing-programming`." +msgid "" +"Note that a queue created using a manager does not have this issue. See :" +"ref:`multiprocessing-programming`." msgstr "" -"Notez que la file créée à l'aide d'un gestionnaire n'a pas ce problème. Voir :ref:`multiprocessing-programming`." +"Notez que la file créée à l'aide d'un gestionnaire n'a pas ce problème. " +"Voir :ref:`multiprocessing-programming`." #: library/multiprocessing.rst:752 -msgid "For an example of the usage of queues for interprocess communication see :ref:`multiprocessing-examples`." +msgid "" +"For an example of the usage of queues for interprocess communication see :" +"ref:`multiprocessing-examples`." msgstr "" -"Pour un exemple d'utilisation de files pour de la communication entre les processus, voir :ref:`multiprocessing-" -"examples`." +"Pour un exemple d'utilisation de files pour de la communication entre les " +"processus, voir :ref:`multiprocessing-examples`." #: library/multiprocessing.rst:758 msgid "" -"Returns a pair ``(conn1, conn2)`` of :class:`~multiprocessing.connection.Connection` objects representing the " -"ends of a pipe." +"Returns a pair ``(conn1, conn2)`` of :class:`~multiprocessing.connection." +"Connection` objects representing the ends of a pipe." msgstr "" -"Renvoie une paire ``(conn1, conn2)`` d'objets :class:`~multiprocessing.connection.Connection` représentant les " -"bouts d'un tube." +"Renvoie une paire ``(conn1, conn2)`` d'objets :class:`~multiprocessing." +"connection.Connection` représentant les bouts d'un tube." #: library/multiprocessing.rst:762 msgid "" -"If *duplex* is ``True`` (the default) then the pipe is bidirectional. If *duplex* is ``False`` then the pipe is " -"unidirectional: ``conn1`` can only be used for receiving messages and ``conn2`` can only be used for sending " +"If *duplex* is ``True`` (the default) then the pipe is bidirectional. If " +"*duplex* is ``False`` then the pipe is unidirectional: ``conn1`` can only be " +"used for receiving messages and ``conn2`` can only be used for sending " "messages." msgstr "" -"Si *duplex* vaut ``True`` (par défaut), alors le tube est bidirectionnel. Si *duplex* vaut ``False`` il est " -"unidirectionnel : ``conn1`` ne peut être utilisé que pour recevoir des messages et ``conn2`` que pour en envoyer." +"Si *duplex* vaut ``True`` (par défaut), alors le tube est bidirectionnel. Si " +"*duplex* vaut ``False`` il est unidirectionnel : ``conn1`` ne peut être " +"utilisé que pour recevoir des messages et ``conn2`` que pour en envoyer." #: library/multiprocessing.rst:770 msgid "" -"Returns a process shared queue implemented using a pipe and a few locks/semaphores. When a process first puts an " -"item on the queue a feeder thread is started which transfers objects from a buffer into the pipe." +"Returns a process shared queue implemented using a pipe and a few locks/" +"semaphores. When a process first puts an item on the queue a feeder thread " +"is started which transfers objects from a buffer into the pipe." msgstr "" -"Renvoie une file partagée entre les processus utilisant un tube et quelques verrous / sémaphores. Quand un " -"processus place initialement un élément sur la file, un fil d'exécution *feeder* est démarré pour transférer les " -"objets du tampon vers le tube." +"Renvoie une file partagée entre les processus utilisant un tube et quelques " +"verrous / sémaphores. Quand un processus place initialement un élément sur " +"la file, un fil d'exécution *feeder* est démarré pour transférer les objets " +"du tampon vers le tube." #: library/multiprocessing.rst:774 msgid "" -"The usual :exc:`queue.Empty` and :exc:`queue.Full` exceptions from the standard library's :mod:`queue` module are " -"raised to signal timeouts." +"The usual :exc:`queue.Empty` and :exc:`queue.Full` exceptions from the " +"standard library's :mod:`queue` module are raised to signal timeouts." msgstr "" -"Les exceptions habituelles :exc:`queue.Empty` et :exc:`queue.Full` du module :mod:`queue` de la bibliothèque " -"standard sont levées pour signaler les *timeouts*." +"Les exceptions habituelles :exc:`queue.Empty` et :exc:`queue.Full` du " +"module :mod:`queue` de la bibliothèque standard sont levées pour signaler " +"les *timeouts*." #: library/multiprocessing.rst:777 msgid "" -":class:`Queue` implements all the methods of :class:`queue.Queue` except for :meth:`~queue.Queue.task_done` and :" -"meth:`~queue.Queue.join`." +":class:`Queue` implements all the methods of :class:`queue.Queue` except " +"for :meth:`~queue.Queue.task_done` and :meth:`~queue.Queue.join`." msgstr "" -":class:`Queue` implémente toutes les méthodes de :class:`queue.Queue` à l'exception de :meth:`~queue.Queue." -"task_done` et :meth:`~queue.Queue.join`." +":class:`Queue` implémente toutes les méthodes de :class:`queue.Queue` à " +"l'exception de :meth:`~queue.Queue.task_done` et :meth:`~queue.Queue.join`." #: library/multiprocessing.rst:782 msgid "" -"Return the approximate size of the queue. Because of multithreading/multiprocessing semantics, this number is " -"not reliable." +"Return the approximate size of the queue. Because of multithreading/" +"multiprocessing semantics, this number is not reliable." msgstr "" -"Renvoie la taille approximative de la file. Ce nombre n'est pas fiable en raison des problématiques de " -"*multithreading* et *multiprocessing*." +"Renvoie la taille approximative de la file. Ce nombre n'est pas fiable en " +"raison des problématiques de *multithreading* et *multiprocessing*." #: library/multiprocessing.rst:785 msgid "" -"Note that this may raise :exc:`NotImplementedError` on Unix platforms like Mac OS X where ``sem_getvalue()`` is " -"not implemented." +"Note that this may raise :exc:`NotImplementedError` on Unix platforms like " +"Mac OS X where ``sem_getvalue()`` is not implemented." msgstr "" -"Notez que cela peut lever une :exc:`NotImplementedError` sous les plateformes Unix telles que Mac OS X où " -"``sem_getvalue()`` n'est pas implémentée." +"Notez que cela peut lever une :exc:`NotImplementedError` sous les " +"plateformes Unix telles que Mac OS X où ``sem_getvalue()`` n'est pas " +"implémentée." #: library/multiprocessing.rst:790 msgid "" -"Return ``True`` if the queue is empty, ``False`` otherwise. Because of multithreading/multiprocessing semantics, " -"this is not reliable." +"Return ``True`` if the queue is empty, ``False`` otherwise. Because of " +"multithreading/multiprocessing semantics, this is not reliable." msgstr "" -"Renvoie ``True`` si la file est vide, ``False`` sinon. Cette valeur n'est pas fiable en raison des problématiques " -"de *multithreading* et *multiprocessing*." +"Renvoie ``True`` si la file est vide, ``False`` sinon. Cette valeur n'est " +"pas fiable en raison des problématiques de *multithreading* et " +"*multiprocessing*." #: library/multiprocessing.rst:795 msgid "" -"Return ``True`` if the queue is full, ``False`` otherwise. Because of multithreading/multiprocessing semantics, " -"this is not reliable." +"Return ``True`` if the queue is full, ``False`` otherwise. Because of " +"multithreading/multiprocessing semantics, this is not reliable." msgstr "" -"Renvoie ``True`` si la file est pleine, ``False`` sinon. Cette valeur n'est pas fiable en raison des " -"problématiques de *multithreading* et *multiprocessing*." +"Renvoie ``True`` si la file est pleine, ``False`` sinon. Cette valeur n'est " +"pas fiable en raison des problématiques de *multithreading* et " +"*multiprocessing*." #: library/multiprocessing.rst:800 msgid "" -"Put obj into the queue. If the optional argument *block* is ``True`` (the default) and *timeout* is ``None`` " -"(the default), block if necessary until a free slot is available. If *timeout* is a positive number, it blocks " -"at most *timeout* seconds and raises the :exc:`queue.Full` exception if no free slot was available within that " -"time. Otherwise (*block* is ``False``), put an item on the queue if a free slot is immediately available, else " -"raise the :exc:`queue.Full` exception (*timeout* is ignored in that case)." -msgstr "" -"Place *obj* dans la file. Si l'argument optionnel *block* vaut ``True`` (par défaut) est que *timeout* est " -"``None`` (par défaut), bloque jusqu'à ce qu'une place libre soit disponible. Si *timeout* est un nombre positif, " -"la méthode bloquera au maximum *timeout* secondes et lève une exception :exc:`queue.Full` si aucune place libre " -"n'a été trouvée dans le temps imparti. Autrement (*block* vaut ``False``), place un élément dans la file si une " -"place libre est immédiatement disponible, ou lève une exception :exc:`queue.Full` dans le cas contraire " -"(*timeout* est ignoré dans ce cas)." +"Put obj into the queue. If the optional argument *block* is ``True`` (the " +"default) and *timeout* is ``None`` (the default), block if necessary until a " +"free slot is available. If *timeout* is a positive number, it blocks at " +"most *timeout* seconds and raises the :exc:`queue.Full` exception if no free " +"slot was available within that time. Otherwise (*block* is ``False``), put " +"an item on the queue if a free slot is immediately available, else raise " +"the :exc:`queue.Full` exception (*timeout* is ignored in that case)." +msgstr "" +"Place *obj* dans la file. Si l'argument optionnel *block* vaut ``True`` (par " +"défaut) est que *timeout* est ``None`` (par défaut), bloque jusqu'à ce " +"qu'une place libre soit disponible. Si *timeout* est un nombre positif, la " +"méthode bloquera au maximum *timeout* secondes et lève une exception :exc:" +"`queue.Full` si aucune place libre n'a été trouvée dans le temps imparti. " +"Autrement (*block* vaut ``False``), place un élément dans la file si une " +"place libre est immédiatement disponible, ou lève une exception :exc:`queue." +"Full` dans le cas contraire (*timeout* est ignoré dans ce cas)." #: library/multiprocessing.rst:809 -msgid "If the queue is closed, :exc:`ValueError` is raised instead of :exc:`AssertionError`." +msgid "" +"If the queue is closed, :exc:`ValueError` is raised instead of :exc:" +"`AssertionError`." msgstr "" -"si la file a été marquée comme fermée, une :exc:`ValueError` est levée. Auparavant, une :exc:`AssertionError` " -"était levée." +"si la file a été marquée comme fermée, une :exc:`ValueError` est levée. " +"Auparavant, une :exc:`AssertionError` était levée." #: library/multiprocessing.rst:815 msgid "Equivalent to ``put(obj, False)``." @@ -967,24 +1174,30 @@ msgstr "Équivalent à ``put(obj, False)``." #: library/multiprocessing.rst:819 msgid "" -"Remove and return an item from the queue. If optional args *block* is ``True`` (the default) and *timeout* is " -"``None`` (the default), block if necessary until an item is available. If *timeout* is a positive number, it " -"blocks at most *timeout* seconds and raises the :exc:`queue.Empty` exception if no item was available within that " -"time. Otherwise (block is ``False``), return an item if one is immediately available, else raise the :exc:`queue." +"Remove and return an item from the queue. If optional args *block* is " +"``True`` (the default) and *timeout* is ``None`` (the default), block if " +"necessary until an item is available. If *timeout* is a positive number, it " +"blocks at most *timeout* seconds and raises the :exc:`queue.Empty` exception " +"if no item was available within that time. Otherwise (block is ``False``), " +"return an item if one is immediately available, else raise the :exc:`queue." "Empty` exception (*timeout* is ignored in that case)." msgstr "" -"Retire et renvoie un élément de la file. Si l'argument optionnel *block* vaut ``True`` (par défaut) et que " -"*timeout* est ``None`` (par défaut), bloque jusqu'à ce qu'un élément soit disponible. Si *timeout* (le délai " -"maximal autorisé) est un nombre positif, la méthode bloque au maximum *timeout* secondes et lève une exception :" -"exc:`queue.Empty` si aucun élément n'est disponible dans le temps imparti. Autrement (*block* vaut ``False``), " -"renvoie un élément s'il est immédiatement disponible, ou lève une exception :exc:`queue.Empty` dans le cas " -"contraire (*timeout* est ignoré dans ce cas)." +"Retire et renvoie un élément de la file. Si l'argument optionnel *block* " +"vaut ``True`` (par défaut) et que *timeout* est ``None`` (par défaut), " +"bloque jusqu'à ce qu'un élément soit disponible. Si *timeout* (le délai " +"maximal autorisé) est un nombre positif, la méthode bloque au maximum " +"*timeout* secondes et lève une exception :exc:`queue.Empty` si aucun élément " +"n'est disponible dans le temps imparti. Autrement (*block* vaut ``False``), " +"renvoie un élément s'il est immédiatement disponible, ou lève une exception :" +"exc:`queue.Empty` dans le cas contraire (*timeout* est ignoré dans ce cas)." #: library/multiprocessing.rst:827 -msgid "If the queue is closed, :exc:`ValueError` is raised instead of :exc:`OSError`." +msgid "" +"If the queue is closed, :exc:`ValueError` is raised instead of :exc:" +"`OSError`." msgstr "" -"si la file a été marquée comme terminée, une :exc:`ValueError` est levée. Auparavant, une :exc:`OSError`. était " -"levée." +"si la file a été marquée comme terminée, une :exc:`ValueError` est levée. " +"Auparavant, une :exc:`OSError`. était levée." #: library/multiprocessing.rst:833 msgid "Equivalent to ``get(False)``." @@ -992,75 +1205,94 @@ msgstr "Équivalent à ``get(False)``." #: library/multiprocessing.rst:835 msgid "" -":class:`multiprocessing.Queue` has a few additional methods not found in :class:`queue.Queue`. These methods are " -"usually unnecessary for most code:" +":class:`multiprocessing.Queue` has a few additional methods not found in :" +"class:`queue.Queue`. These methods are usually unnecessary for most code:" msgstr "" -":class:`multiprocessing.Queue` possède quelques méthodes additionnelles non présentes dans :class:`queue.Queue`. " -"Ces méthodes ne sont habituellement pas nécessaires pour la plupart des codes :" +":class:`multiprocessing.Queue` possède quelques méthodes additionnelles non " +"présentes dans :class:`queue.Queue`. Ces méthodes ne sont habituellement pas " +"nécessaires pour la plupart des codes :" #: library/multiprocessing.rst:841 msgid "" -"Indicate that no more data will be put on this queue by the current process. The background thread will quit " -"once it has flushed all buffered data to the pipe. This is called automatically when the queue is garbage " +"Indicate that no more data will be put on this queue by the current " +"process. The background thread will quit once it has flushed all buffered " +"data to the pipe. This is called automatically when the queue is garbage " "collected." msgstr "" -"Indique que plus aucune donnée ne peut être placée sur la file par le processus courant. Le fil d'exécution en " -"arrière-plan se terminera quand il aura transféré toutes les données du tampon vers le tube. Elle est appelée " +"Indique que plus aucune donnée ne peut être placée sur la file par le " +"processus courant. Le fil d'exécution en arrière-plan se terminera quand il " +"aura transféré toutes les données du tampon vers le tube. Elle est appelée " "automatiquement quand la file est collectée par le ramasse-miettes." #: library/multiprocessing.rst:848 msgid "" -"Join the background thread. This can only be used after :meth:`close` has been called. It blocks until the " -"background thread exits, ensuring that all data in the buffer has been flushed to the pipe." +"Join the background thread. This can only be used after :meth:`close` has " +"been called. It blocks until the background thread exits, ensuring that all " +"data in the buffer has been flushed to the pipe." msgstr "" -"Attend le fil d'exécution d'arrière-plan. Elle peut seulement être utilisée une fois que :meth:`close` a été " -"appelée. Elle bloque jusqu'à ce que le fil d'arrière-plan se termine, assurant que toutes les données du tampon " -"ont été transmises au tube." +"Attend le fil d'exécution d'arrière-plan. Elle peut seulement être utilisée " +"une fois que :meth:`close` a été appelée. Elle bloque jusqu'à ce que le fil " +"d'arrière-plan se termine, assurant que toutes les données du tampon ont été " +"transmises au tube." #: library/multiprocessing.rst:852 msgid "" -"By default if a process is not the creator of the queue then on exit it will attempt to join the queue's " -"background thread. The process can call :meth:`cancel_join_thread` to make :meth:`join_thread` do nothing." +"By default if a process is not the creator of the queue then on exit it will " +"attempt to join the queue's background thread. The process can call :meth:" +"`cancel_join_thread` to make :meth:`join_thread` do nothing." msgstr "" -"Par défaut si un processus n'est pas le créateur de la file alors à la fermeture elle essaie d'attendre le fil " -"d'exécution d'arrière-plan de la file. Le processus peut appeler :meth:`cancel_join_thread` pour que :meth:" +"Par défaut si un processus n'est pas le créateur de la file alors à la " +"fermeture elle essaie d'attendre le fil d'exécution d'arrière-plan de la " +"file. Le processus peut appeler :meth:`cancel_join_thread` pour que :meth:" "`join_thread` ne fasse rien." #: library/multiprocessing.rst:858 msgid "" -"Prevent :meth:`join_thread` from blocking. In particular, this prevents the background thread from being joined " -"automatically when the process exits -- see :meth:`join_thread`." +"Prevent :meth:`join_thread` from blocking. In particular, this prevents the " +"background thread from being joined automatically when the process exits -- " +"see :meth:`join_thread`." msgstr "" -"Empêche :meth:`join_thread` de bloquer. En particulier, cela empêche le fil d'arrière-plan d'être attendu " -"automatiquement quand le processus se ferme – voir :meth:`join_thread`." +"Empêche :meth:`join_thread` de bloquer. En particulier, cela empêche le fil " +"d'arrière-plan d'être attendu automatiquement quand le processus se ferme – " +"voir :meth:`join_thread`." #: library/multiprocessing.rst:862 msgid "" -"A better name for this method might be ``allow_exit_without_flush()``. It is likely to cause enqueued data to " -"lost, and you almost certainly will not need to use it. It is really only there if you need the current process " -"to exit immediately without waiting to flush enqueued data to the underlying pipe, and you don't care about lost " -"data." +"A better name for this method might be ``allow_exit_without_flush()``. It " +"is likely to cause enqueued data to lost, and you almost certainly will not " +"need to use it. It is really only there if you need the current process to " +"exit immediately without waiting to flush enqueued data to the underlying " +"pipe, and you don't care about lost data." msgstr "" -"Un meilleur nom pour cette méthode pourrait être ``allow_exit_without_flush()``. Cela peut provoquer des pertes " -"de données placées dans la file, et il est très rare d'avoir besoin de l'utiliser. Elle n'est là que si vous " -"souhaitez terminer immédiatement le processus sans transférer les données du tampon, et que vous ne vous " -"inquiétez pas de perdre des données." +"Un meilleur nom pour cette méthode pourrait être " +"``allow_exit_without_flush()``. Cela peut provoquer des pertes de données " +"placées dans la file, et il est très rare d'avoir besoin de l'utiliser. Elle " +"n'est là que si vous souhaitez terminer immédiatement le processus sans " +"transférer les données du tampon, et que vous ne vous inquiétez pas de " +"perdre des données." #: library/multiprocessing.rst:871 msgid "" -"This class's functionality requires a functioning shared semaphore implementation on the host operating system. " -"Without one, the functionality in this class will be disabled, and attempts to instantiate a :class:`Queue` will " -"result in an :exc:`ImportError`. See :issue:`3770` for additional information. The same holds true for any of " -"the specialized queue types listed below." +"This class's functionality requires a functioning shared semaphore " +"implementation on the host operating system. Without one, the functionality " +"in this class will be disabled, and attempts to instantiate a :class:`Queue` " +"will result in an :exc:`ImportError`. See :issue:`3770` for additional " +"information. The same holds true for any of the specialized queue types " +"listed below." msgstr "" -"Le fonctionnement de cette classe requiert une implémentation de sémaphore partagé sur le système d'exploitation " -"hôte. Sans cela, la fonctionnalité est désactivée et la tentative d'instancier une :class:`Queue` lève une :exc:" -"`ImportError`. Voir :issue:`3770` pour plus d'informations. Cette remarque reste valable pour les autres types de " -"files spécialisées définies par la suite." +"Le fonctionnement de cette classe requiert une implémentation de sémaphore " +"partagé sur le système d'exploitation hôte. Sans cela, la fonctionnalité est " +"désactivée et la tentative d'instancier une :class:`Queue` lève une :exc:" +"`ImportError`. Voir :issue:`3770` pour plus d'informations. Cette remarque " +"reste valable pour les autres types de files spécialisées définies par la " +"suite." #: library/multiprocessing.rst:880 -msgid "It is a simplified :class:`Queue` type, very close to a locked :class:`Pipe`." -msgstr "Un type de :class:`Queue` simplifié, très proche d'un :class:`Pipe` avec verrou." +msgid "" +"It is a simplified :class:`Queue` type, very close to a locked :class:`Pipe`." +msgstr "" +"Un type de :class:`Queue` simplifié, très proche d'un :class:`Pipe` avec " +"verrou." #: library/multiprocessing.rst:884 msgid "Close the queue: release internal resources." @@ -1068,11 +1300,12 @@ msgstr "Ferme la file : libère les ressources internes." #: library/multiprocessing.rst:886 msgid "" -"A queue must not be used anymore after it is closed. For example, :meth:`get`, :meth:`put` and :meth:`empty` " -"methods must no longer be called." +"A queue must not be used anymore after it is closed. For example, :meth:" +"`get`, :meth:`put` and :meth:`empty` methods must no longer be called." msgstr "" -"Une file ne doit plus être utilisée après sa fermeture. Par exemple, les méthodes :meth:`get`, :meth:`put` et :" -"meth:`empty` ne doivent plus être appelées." +"Une file ne doit plus être utilisée après sa fermeture. Par exemple, les " +"méthodes :meth:`get`, :meth:`put` et :meth:`empty` ne doivent plus être " +"appelées." #: library/multiprocessing.rst:894 msgid "Return ``True`` if the queue is empty, ``False`` otherwise." @@ -1088,48 +1321,62 @@ msgstr "Place *item* dans la file." #: library/multiprocessing.rst:907 msgid "" -":class:`JoinableQueue`, a :class:`Queue` subclass, is a queue which additionally has :meth:`task_done` and :meth:" -"`join` methods." +":class:`JoinableQueue`, a :class:`Queue` subclass, is a queue which " +"additionally has :meth:`task_done` and :meth:`join` methods." msgstr "" -":class:`JoinableQueue`, une sous-classe de :class:`Queue`, est une file qui ajoute des méthodes :meth:`task_done` " -"et :meth:`join`." +":class:`JoinableQueue`, une sous-classe de :class:`Queue`, est une file qui " +"ajoute des méthodes :meth:`task_done` et :meth:`join`." #: library/multiprocessing.rst:912 msgid "" -"Indicate that a formerly enqueued task is complete. Used by queue consumers. For each :meth:`~Queue.get` used to " -"fetch a task, a subsequent call to :meth:`task_done` tells the queue that the processing on the task is complete." +"Indicate that a formerly enqueued task is complete. Used by queue " +"consumers. For each :meth:`~Queue.get` used to fetch a task, a subsequent " +"call to :meth:`task_done` tells the queue that the processing on the task is " +"complete." msgstr "" -"Indique qu'une tâche précédemment placée dans la file est achevée. Utilisée par les consommateurs de la file. " -"Pour chaque :meth:`~Queue.get` utilisée pour récupérer une tâche, un appel ultérieur à :meth:`task_done` indique " -"à la file que le traitement de la tâche est terminé." +"Indique qu'une tâche précédemment placée dans la file est achevée. Utilisée " +"par les consommateurs de la file. Pour chaque :meth:`~Queue.get` utilisée " +"pour récupérer une tâche, un appel ultérieur à :meth:`task_done` indique à " +"la file que le traitement de la tâche est terminé." #: library/multiprocessing.rst:917 msgid "" -"If a :meth:`~queue.Queue.join` is currently blocking, it will resume when all items have been processed (meaning " -"that a :meth:`task_done` call was received for every item that had been :meth:`~Queue.put` into the queue)." +"If a :meth:`~queue.Queue.join` is currently blocking, it will resume when " +"all items have been processed (meaning that a :meth:`task_done` call was " +"received for every item that had been :meth:`~Queue.put` into the queue)." msgstr "" -"Si un :meth:`~queue.Queue.join` est actuellement bloquant, il se débloquera quand tous les éléments auront été " -"traités (signifiant qu'un appel à :meth:`task_done` a été reçu pour chaque élément ayant été placé via :meth:" -"`~Queue.put` dans la file)." +"Si un :meth:`~queue.Queue.join` est actuellement bloquant, il se débloquera " +"quand tous les éléments auront été traités (signifiant qu'un appel à :meth:" +"`task_done` a été reçu pour chaque élément ayant été placé via :meth:`~Queue." +"put` dans la file)." #: library/multiprocessing.rst:921 -msgid "Raises a :exc:`ValueError` if called more times than there were items placed in the queue." -msgstr "Lève une exception :exc:`ValueError` si appelée plus de fois qu'il y avait d'éléments dans la file." +msgid "" +"Raises a :exc:`ValueError` if called more times than there were items placed " +"in the queue." +msgstr "" +"Lève une exception :exc:`ValueError` si appelée plus de fois qu'il y avait " +"d'éléments dans la file." #: library/multiprocessing.rst:927 msgid "Block until all items in the queue have been gotten and processed." -msgstr "Bloque jusqu'à ce que tous les éléments de la file aient été récupérés et traités." +msgstr "" +"Bloque jusqu'à ce que tous les éléments de la file aient été récupérés et " +"traités." #: library/multiprocessing.rst:929 msgid "" -"The count of unfinished tasks goes up whenever an item is added to the queue. The count goes down whenever a " -"consumer calls :meth:`task_done` to indicate that the item was retrieved and all work on it is complete. When " -"the count of unfinished tasks drops to zero, :meth:`~queue.Queue.join` unblocks." +"The count of unfinished tasks goes up whenever an item is added to the " +"queue. The count goes down whenever a consumer calls :meth:`task_done` to " +"indicate that the item was retrieved and all work on it is complete. When " +"the count of unfinished tasks drops to zero, :meth:`~queue.Queue.join` " +"unblocks." msgstr "" -"Le compteur des tâches non accomplies augmente chaque fois qu'un élément est ajouté à la file. Le compteur " -"redescend chaque fois qu'un consommateur appelle :meth:`task_done` pour indiquer qu'un élément a été récupéré et " -"que tout le travail qui le concerne est complété. Quand le compteur des tâches non accomplies atteint zéro, :meth:" -"`~queue.Queue.join` est débloquée." +"Le compteur des tâches non accomplies augmente chaque fois qu'un élément est " +"ajouté à la file. Le compteur redescend chaque fois qu'un consommateur " +"appelle :meth:`task_done` pour indiquer qu'un élément a été récupéré et que " +"tout le travail qui le concerne est complété. Quand le compteur des tâches " +"non accomplies atteint zéro, :meth:`~queue.Queue.join` est débloquée." #: library/multiprocessing.rst:937 msgid "Miscellaneous" @@ -1140,8 +1387,12 @@ msgid "Return list of all live children of the current process." msgstr "Renvoie la liste de tous les enfants vivants du processus courant." #: library/multiprocessing.rst:943 -msgid "Calling this has the side effect of \"joining\" any processes which have already finished." -msgstr "Appeler cette méthode provoque l'effet de bord d'attendre tout processus qui n'a pas encore terminé." +msgid "" +"Calling this has the side effect of \"joining\" any processes which have " +"already finished." +msgstr "" +"Appeler cette méthode provoque l'effet de bord d'attendre tout processus qui " +"n'a pas encore terminé." #: library/multiprocessing.rst:948 msgid "Return the number of CPUs in the system." @@ -1149,11 +1400,13 @@ msgstr "Renvoie le nombre de CPU sur le système." #: library/multiprocessing.rst:950 msgid "" -"This number is not equivalent to the number of CPUs the current process can use. The number of usable CPUs can " -"be obtained with ``len(os.sched_getaffinity(0))``" +"This number is not equivalent to the number of CPUs the current process can " +"use. The number of usable CPUs can be obtained with ``len(os." +"sched_getaffinity(0))``" msgstr "" -"Ce nombre n'est pas équivalent au nombre de CPUs que le processus courant peut utiliser. Le nombre de CPUs " -"utilisables peut être obtenu avec ``len(os.sched_getaffinity(0))``" +"Ce nombre n'est pas équivalent au nombre de CPUs que le processus courant " +"peut utiliser. Le nombre de CPUs utilisables peut être obtenu avec ``len(os." +"sched_getaffinity(0))``" #: library/multiprocessing.rst:954 msgid "May raise :exc:`NotImplementedError`." @@ -1164,7 +1417,8 @@ msgid ":func:`os.cpu_count`" msgstr ":func:`os.cpu_count`" #: library/multiprocessing.rst:961 -msgid "Return the :class:`Process` object corresponding to the current process." +msgid "" +"Return the :class:`Process` object corresponding to the current process." msgstr "Renvoie l'objet :class:`Process` correspondant au processus courant." #: library/multiprocessing.rst:963 @@ -1173,96 +1427,121 @@ msgstr "Un analogue à :func:`threading.current_thread`." #: library/multiprocessing.rst:967 msgid "" -"Return the :class:`Process` object corresponding to the parent process of the :func:`current_process`. For the " -"main process, ``parent_process`` will be ``None``." +"Return the :class:`Process` object corresponding to the parent process of " +"the :func:`current_process`. For the main process, ``parent_process`` will " +"be ``None``." msgstr "" -"Renvoie l'objet :class:`Process` correspondant au processus père de :func:`current_process`. Pour le processus " -"maître, ``parent_process`` vaut ``None``." +"Renvoie l'objet :class:`Process` correspondant au processus père de :func:" +"`current_process`. Pour le processus maître, ``parent_process`` vaut " +"``None``." #: library/multiprocessing.rst:975 msgid "" -"Add support for when a program which uses :mod:`multiprocessing` has been frozen to produce a Windows " -"executable. (Has been tested with **py2exe**, **PyInstaller** and **cx_Freeze**.)" +"Add support for when a program which uses :mod:`multiprocessing` has been " +"frozen to produce a Windows executable. (Has been tested with **py2exe**, " +"**PyInstaller** and **cx_Freeze**.)" msgstr "" -"Ajoute le support des programmes utilisant :mod:`multiprocessing` qui ont été figés pour produire un exécutable " -"Windows (testé avec **py2exe**, **PyInstaller** et **cx_Freeze**)." +"Ajoute le support des programmes utilisant :mod:`multiprocessing` qui ont " +"été figés pour produire un exécutable Windows (testé avec **py2exe**, " +"**PyInstaller** et **cx_Freeze**)." #: library/multiprocessing.rst:979 msgid "" -"One needs to call this function straight after the ``if __name__ == '__main__'`` line of the main module. For " -"example::" +"One needs to call this function straight after the ``if __name__ == " +"'__main__'`` line of the main module. For example::" msgstr "" -"Cette fonction doit être appelée juste après la ligne ``if __name__ == '__main__'`` du module principal. Par " -"exemple ::" +"Cette fonction doit être appelée juste après la ligne ``if __name__ == " +"'__main__'`` du module principal. Par exemple ::" #: library/multiprocessing.rst:991 msgid "" -"If the ``freeze_support()`` line is omitted then trying to run the frozen executable will raise :exc:" -"`RuntimeError`." +"If the ``freeze_support()`` line is omitted then trying to run the frozen " +"executable will raise :exc:`RuntimeError`." msgstr "" -"Si la ligne ``freeze_support()`` est omise, alors tenter de lancer l'exécutable figé lève une :exc:`RuntimeError`." +"Si la ligne ``freeze_support()`` est omise, alors tenter de lancer " +"l'exécutable figé lève une :exc:`RuntimeError`." #: library/multiprocessing.rst:994 msgid "" -"Calling ``freeze_support()`` has no effect when invoked on any operating system other than Windows. In addition, " -"if the module is being run normally by the Python interpreter on Windows (the program has not been frozen), then " +"Calling ``freeze_support()`` has no effect when invoked on any operating " +"system other than Windows. In addition, if the module is being run normally " +"by the Python interpreter on Windows (the program has not been frozen), then " "``freeze_support()`` has no effect." msgstr "" -"Appeler ``freeze_support()`` n'a pas d'effet quand elle est invoquée sur un système d'exploitation autre que " -"Windows. De plus, si le module est lancé normalement par l'interpréteur Python sous Windows (le programme n'a pas " -"été figé), alors ``freeze_support()`` n'a pas d'effet." +"Appeler ``freeze_support()`` n'a pas d'effet quand elle est invoquée sur un " +"système d'exploitation autre que Windows. De plus, si le module est lancé " +"normalement par l'interpréteur Python sous Windows (le programme n'a pas été " +"figé), alors ``freeze_support()`` n'a pas d'effet." #: library/multiprocessing.rst:1001 msgid "" -"Returns a list of the supported start methods, the first of which is the default. The possible start methods are " -"``'fork'``, ``'spawn'`` and ``'forkserver'``. On Windows only ``'spawn'`` is available. On Unix ``'fork'`` and " -"``'spawn'`` are always supported, with ``'fork'`` being the default." +"Returns a list of the supported start methods, the first of which is the " +"default. The possible start methods are ``'fork'``, ``'spawn'`` and " +"``'forkserver'``. On Windows only ``'spawn'`` is available. On Unix " +"``'fork'`` and ``'spawn'`` are always supported, with ``'fork'`` being the " +"default." msgstr "" -"Renvoie la liste des méthodes de démarrage supportées, la première étant celle par défaut. Les méthodes de " -"démarrage possibles sont ``'fork'``, ``'spawn'`` et ``'forkserver'``. Sous Windows seule ``'spawn'`` est " -"disponible. Sous Unix ``'fork'`` et ``'spawn'`` sont disponibles, ``'fork'`` étant celle par défaut." +"Renvoie la liste des méthodes de démarrage supportées, la première étant " +"celle par défaut. Les méthodes de démarrage possibles sont ``'fork'``, " +"``'spawn'`` et ``'forkserver'``. Sous Windows seule ``'spawn'`` est " +"disponible. Sous Unix ``'fork'`` et ``'spawn'`` sont disponibles, ``'fork'`` " +"étant celle par défaut." #: library/multiprocessing.rst:1011 -msgid "Return a context object which has the same attributes as the :mod:`multiprocessing` module." -msgstr "Renvoie un contexte ayant les mêmes attributs que le module :mod:`multiprocessing`." +msgid "" +"Return a context object which has the same attributes as the :mod:" +"`multiprocessing` module." +msgstr "" +"Renvoie un contexte ayant les mêmes attributs que le module :mod:" +"`multiprocessing`." #: library/multiprocessing.rst:1014 msgid "" -"If *method* is ``None`` then the default context is returned. Otherwise *method* should be ``'fork'``, " -"``'spawn'``, ``'forkserver'``. :exc:`ValueError` is raised if the specified start method is not available." +"If *method* is ``None`` then the default context is returned. Otherwise " +"*method* should be ``'fork'``, ``'spawn'``, ``'forkserver'``. :exc:" +"`ValueError` is raised if the specified start method is not available." msgstr "" -"Si *method* est ``None`` le contexte par défaut est renvoyé. Sinon *method* doit valoir ``'fork'``, ``'spawn'`` " -"ou ``'forkserver'``. Une :exc:`ValueError` est levée si la méthode de démarrage spécifiée n'est pas disponible." +"Si *method* est ``None`` le contexte par défaut est renvoyé. Sinon *method* " +"doit valoir ``'fork'``, ``'spawn'`` ou ``'forkserver'``. Une :exc:" +"`ValueError` est levée si la méthode de démarrage spécifiée n'est pas " +"disponible." #: library/multiprocessing.rst:1023 msgid "Return the name of start method used for starting processes." -msgstr "Renvoie le nom de la méthode de démarrage utilisée pour démarrer le processus." +msgstr "" +"Renvoie le nom de la méthode de démarrage utilisée pour démarrer le " +"processus." #: library/multiprocessing.rst:1025 msgid "" -"If the start method has not been fixed and *allow_none* is false, then the start method is fixed to the default " -"and the name is returned. If the start method has not been fixed and *allow_none* is true then ``None`` is " -"returned." +"If the start method has not been fixed and *allow_none* is false, then the " +"start method is fixed to the default and the name is returned. If the start " +"method has not been fixed and *allow_none* is true then ``None`` is returned." msgstr "" -"Si le nom de la méthode n'a pas été fixé et que *allow_none* est faux, alors la méthode de démarrage est réglée à " -"celle par défaut et son nom est renvoyé. Si la méthode n'a pas été fixée et que *allow_none* est vrai, ``None`` " -"est renvoyé." +"Si le nom de la méthode n'a pas été fixé et que *allow_none* est faux, alors " +"la méthode de démarrage est réglée à celle par défaut et son nom est " +"renvoyé. Si la méthode n'a pas été fixée et que *allow_none* est vrai, " +"``None`` est renvoyé." #: library/multiprocessing.rst:1030 msgid "" -"The return value can be ``'fork'``, ``'spawn'``, ``'forkserver'`` or ``None``. ``'fork'`` is the default on " -"Unix, while ``'spawn'`` is the default on Windows." +"The return value can be ``'fork'``, ``'spawn'``, ``'forkserver'`` or " +"``None``. ``'fork'`` is the default on Unix, while ``'spawn'`` is the " +"default on Windows." msgstr "" -"La valeur de retour peut être ``'fork'``, ``'spawn'``, ``'forkserver'`` ou ``None``. ``'fork'`` est la valeur par " -"défaut sous Unix, ``'spawn'`` est celle sous Windows." +"La valeur de retour peut être ``'fork'``, ``'spawn'``, ``'forkserver'`` ou " +"``None``. ``'fork'`` est la valeur par défaut sous Unix, ``'spawn'`` est " +"celle sous Windows." #: library/multiprocessing.rst:1038 msgid "" -"Sets the path of the Python interpreter to use when starting a child process. (By default :data:`sys.executable` " -"is used). Embedders will probably need to do some thing like ::" +"Sets the path of the Python interpreter to use when starting a child " +"process. (By default :data:`sys.executable` is used). Embedders will " +"probably need to do some thing like ::" msgstr "" -"Définit le chemin de l'interpréteur Python à utiliser pour démarrer un processus fils. (Par défaut :data:`sys." -"executable` est utilisé). Les intégrateurs devront probablement faire quelque chose comme ::" +"Définit le chemin de l'interpréteur Python à utiliser pour démarrer un " +"processus fils. (Par défaut :data:`sys.executable` est utilisé). Les " +"intégrateurs devront probablement faire quelque chose comme ::" #: library/multiprocessing.rst:1044 msgid "before they can create child processes." @@ -1270,32 +1549,38 @@ msgstr "avant de pouvoir créer des processus fils." #: library/multiprocessing.rst:1046 msgid "Now supported on Unix when the ``'spawn'`` start method is used." -msgstr "Maintenant supporté sous Unix quand la méthode de démarrage ``'spawn'`` est utilisée." +msgstr "" +"Maintenant supporté sous Unix quand la méthode de démarrage ``'spawn'`` est " +"utilisée." #: library/multiprocessing.rst:1051 msgid "" -"Set the method which should be used to start child processes. *method* can be ``'fork'``, ``'spawn'`` or " -"``'forkserver'``." +"Set the method which should be used to start child processes. *method* can " +"be ``'fork'``, ``'spawn'`` or ``'forkserver'``." msgstr "" -"Règle la méthode qui doit être utilisée pour démarrer un processus fils. *method* peut être ``'fork'``, " -"``'spawn'`` ou ``'forkserver'``." +"Règle la méthode qui doit être utilisée pour démarrer un processus fils. " +"*method* peut être ``'fork'``, ``'spawn'`` ou ``'forkserver'``." #: library/multiprocessing.rst:1054 msgid "" -"Note that this should be called at most once, and it should be protected inside the ``if __name__ == '__main__'`` " -"clause of the main module." +"Note that this should be called at most once, and it should be protected " +"inside the ``if __name__ == '__main__'`` clause of the main module." msgstr "" -"Notez que cette fonction ne devrait être appelée qu'une fois au plus, et l'appel devrait être protégé à " -"l'intérieur d'une clause ``if __name__ == '__main__'`` dans le module principal." +"Notez que cette fonction ne devrait être appelée qu'une fois au plus, et " +"l'appel devrait être protégé à l'intérieur d'une clause ``if __name__ == " +"'__main__'`` dans le module principal." #: library/multiprocessing.rst:1062 msgid "" -":mod:`multiprocessing` contains no analogues of :func:`threading.active_count`, :func:`threading.enumerate`, :" -"func:`threading.settrace`, :func:`threading.setprofile`, :class:`threading.Timer`, or :class:`threading.local`." +":mod:`multiprocessing` contains no analogues of :func:`threading." +"active_count`, :func:`threading.enumerate`, :func:`threading.settrace`, :" +"func:`threading.setprofile`, :class:`threading.Timer`, or :class:`threading." +"local`." msgstr "" -":mod:`multiprocessing` ne contient pas d'analogues à :func:`threading.active_count`, :func:`threading." -"enumerate`, :func:`threading.settrace`, :func:`threading.setprofile`, :class:`threading.Timer`, ou :class:" -"`threading.local`." +":mod:`multiprocessing` ne contient pas d'analogues à :func:`threading." +"active_count`, :func:`threading.enumerate`, :func:`threading.settrace`, :" +"func:`threading.setprofile`, :class:`threading.Timer`, ou :class:`threading." +"local`." #: library/multiprocessing.rst:1069 msgid "Connection Objects" @@ -1303,43 +1588,53 @@ msgstr "Objets de connexions" #: library/multiprocessing.rst:1073 msgid "" -"Connection objects allow the sending and receiving of picklable objects or strings. They can be thought of as " -"message oriented connected sockets." +"Connection objects allow the sending and receiving of picklable objects or " +"strings. They can be thought of as message oriented connected sockets." msgstr "" -"Les objets de connexion autorisent l'envoi et la réception d'objets sérialisables ou de chaînes de caractères. " -"Ils peuvent être vus comme des interfaces de connexion (*sockets*) connectées orientées messages." +"Les objets de connexion autorisent l'envoi et la réception d'objets " +"sérialisables ou de chaînes de caractères. Ils peuvent être vus comme des " +"interfaces de connexion (*sockets*) connectées orientées messages." #: library/multiprocessing.rst:1076 msgid "" -"Connection objects are usually created using :func:`Pipe ` -- see also :ref:" -"`multiprocessing-listeners-clients`." +"Connection objects are usually created using :func:`Pipe ` -- see also :ref:`multiprocessing-listeners-clients`." msgstr "" -"Les objets de connexion sont habituellement créés via :func:`Pipe ` – voir aussi :ref:" -"`multiprocessing-listeners-clients`." +"Les objets de connexion sont habituellement créés via :func:`Pipe " +"` – voir aussi :ref:`multiprocessing-listeners-" +"clients`." #: library/multiprocessing.rst:1084 -msgid "Send an object to the other end of the connection which should be read using :meth:`recv`." -msgstr "Envoie un objet sur l'autre bout de la connexion, qui devra être lu avec :meth:`recv`." +msgid "" +"Send an object to the other end of the connection which should be read " +"using :meth:`recv`." +msgstr "" +"Envoie un objet sur l'autre bout de la connexion, qui devra être lu avec :" +"meth:`recv`." #: library/multiprocessing.rst:1087 msgid "" -"The object must be picklable. Very large pickles (approximately 32 MiB+, though it depends on the OS) may raise " -"a :exc:`ValueError` exception." +"The object must be picklable. Very large pickles (approximately 32 MiB+, " +"though it depends on the OS) may raise a :exc:`ValueError` exception." msgstr "" -"L'objet doit être sérialisable. Les *pickles* très larges (approximativement 32 Mo+, bien que cela dépende de " -"l'OS) pourront lever une exception :exc:`ValueError`." +"L'objet doit être sérialisable. Les *pickles* très larges (approximativement " +"32 Mo+, bien que cela dépende de l'OS) pourront lever une exception :exc:" +"`ValueError`." #: library/multiprocessing.rst:1092 msgid "" -"Return an object sent from the other end of the connection using :meth:`send`. Blocks until there is something " -"to receive. Raises :exc:`EOFError` if there is nothing left to receive and the other end was closed." +"Return an object sent from the other end of the connection using :meth:" +"`send`. Blocks until there is something to receive. Raises :exc:`EOFError` " +"if there is nothing left to receive and the other end was closed." msgstr "" -"Renvoie un objet envoyé depuis l'autre bout de la connexion en utilisant :meth:`send`. Bloque jusqu'à ce que " -"quelque chose soit reçu. Lève une :exc:`EOFError` s'il n'y a plus rien à recevoir et que l'autre bout a été fermé." +"Renvoie un objet envoyé depuis l'autre bout de la connexion en utilisant :" +"meth:`send`. Bloque jusqu'à ce que quelque chose soit reçu. Lève une :exc:" +"`EOFError` s'il n'y a plus rien à recevoir et que l'autre bout a été fermé." #: library/multiprocessing.rst:1099 msgid "Return the file descriptor or handle used by the connection." -msgstr "Renvoie le descripteur de fichier ou identifiant utilisé par la connexion." +msgstr "" +"Renvoie le descripteur de fichier ou identifiant utilisé par la connexion." #: library/multiprocessing.rst:1103 msgid "Close the connection." @@ -1347,107 +1642,133 @@ msgstr "Ferme la connexion." #: library/multiprocessing.rst:1105 msgid "This is called automatically when the connection is garbage collected." -msgstr "Elle est appelée automatiquement quand la connexion est collectée par le ramasse-miettes." +msgstr "" +"Elle est appelée automatiquement quand la connexion est collectée par le " +"ramasse-miettes." #: library/multiprocessing.rst:1109 msgid "Return whether there is any data available to be read." -msgstr "Renvoie vrai ou faux selon si des données sont disponibles à la lecture." +msgstr "" +"Renvoie vrai ou faux selon si des données sont disponibles à la lecture." #: library/multiprocessing.rst:1111 msgid "" -"If *timeout* is not specified then it will return immediately. If *timeout* is a number then this specifies the " -"maximum time in seconds to block. If *timeout* is ``None`` then an infinite timeout is used." +"If *timeout* is not specified then it will return immediately. If *timeout* " +"is a number then this specifies the maximum time in seconds to block. If " +"*timeout* is ``None`` then an infinite timeout is used." msgstr "" -"Si *timeout* n'est pas spécifié la méthode renverra immédiatement. Si *timeout* est un nombre alors il spécifie " -"le temps maximum de blocage en secondes. Si *timeout* est ``None``, un temps d'attente infini est utilisé." +"Si *timeout* n'est pas spécifié la méthode renverra immédiatement. Si " +"*timeout* est un nombre alors il spécifie le temps maximum de blocage en " +"secondes. Si *timeout* est ``None``, un temps d'attente infini est utilisé." #: library/multiprocessing.rst:1115 msgid "" -"Note that multiple connection objects may be polled at once by using :func:`multiprocessing.connection.wait`." +"Note that multiple connection objects may be polled at once by using :func:" +"`multiprocessing.connection.wait`." msgstr "" -"Notez que plusieurs objets de connexions peuvent être attendus en même temps à l'aide de :func:`multiprocessing." -"connection.wait`." +"Notez que plusieurs objets de connexions peuvent être attendus en même temps " +"à l'aide de :func:`multiprocessing.connection.wait`." #: library/multiprocessing.rst:1120 msgid "Send byte data from a :term:`bytes-like object` as a complete message." -msgstr "Envoie des données binaires depuis un :term:`bytes-like object` comme un message complet." +msgstr "" +"Envoie des données binaires depuis un :term:`bytes-like object` comme un " +"message complet." #: library/multiprocessing.rst:1122 msgid "" -"If *offset* is given then data is read from that position in *buffer*. If *size* is given then that many bytes " -"will be read from buffer. Very large buffers (approximately 32 MiB+, though it depends on the OS) may raise a :" +"If *offset* is given then data is read from that position in *buffer*. If " +"*size* is given then that many bytes will be read from buffer. Very large " +"buffers (approximately 32 MiB+, though it depends on the OS) may raise a :" "exc:`ValueError` exception" msgstr "" -"Si *offset* est fourni, les données sont lues depuis cette position dans le tampon *buffer*. Si *size* est " -"fourni, il indique le nombre d'octets qui seront lus depuis *buffer*. Les tampons très larges (approximativement " -"32 MiB+, bien que cela dépende de l'OS) pourront lever une exception :exc:`ValueError`." +"Si *offset* est fourni, les données sont lues depuis cette position dans le " +"tampon *buffer*. Si *size* est fourni, il indique le nombre d'octets qui " +"seront lus depuis *buffer*. Les tampons très larges (approximativement 32 MiB" +"+, bien que cela dépende de l'OS) pourront lever une exception :exc:" +"`ValueError`." #: library/multiprocessing.rst:1129 msgid "" -"Return a complete message of byte data sent from the other end of the connection as a string. Blocks until there " -"is something to receive. Raises :exc:`EOFError` if there is nothing left to receive and the other end has closed." +"Return a complete message of byte data sent from the other end of the " +"connection as a string. Blocks until there is something to receive. Raises :" +"exc:`EOFError` if there is nothing left to receive and the other end has " +"closed." msgstr "" -"Renvoie un message complet de données binaires envoyées depuis l'autre bout de la connexion comme une chaîne de " -"caractères. Bloque jusqu'à ce qu'il y ait quelque chose à recevoir. Lève une :exc:`EOFError` s'il ne reste rien à " +"Renvoie un message complet de données binaires envoyées depuis l'autre bout " +"de la connexion comme une chaîne de caractères. Bloque jusqu'à ce qu'il y " +"ait quelque chose à recevoir. Lève une :exc:`EOFError` s'il ne reste rien à " "recevoir et que l'autre côté de la connexion a été fermé." #: library/multiprocessing.rst:1134 msgid "" -"If *maxlength* is specified and the message is longer than *maxlength* then :exc:`OSError` is raised and the " -"connection will no longer be readable." +"If *maxlength* is specified and the message is longer than *maxlength* then :" +"exc:`OSError` is raised and the connection will no longer be readable." msgstr "" -"Si *maxlength* est précisé que que le message est plus long que *maxlength* alors une :exc:`OSError` est levée et " -"la connexion n'est plus lisible." +"Si *maxlength* est précisé que que le message est plus long que *maxlength* " +"alors une :exc:`OSError` est levée et la connexion n'est plus lisible." #: library/multiprocessing.rst:1138 -msgid "This function used to raise :exc:`IOError`, which is now an alias of :exc:`OSError`." -msgstr "Cette fonction levait auparavant une :exc:`IOError`, qui est maintenant un alias pour :exc:`OSError`." +msgid "" +"This function used to raise :exc:`IOError`, which is now an alias of :exc:" +"`OSError`." +msgstr "" +"Cette fonction levait auparavant une :exc:`IOError`, qui est maintenant un " +"alias pour :exc:`OSError`." #: library/multiprocessing.rst:1145 msgid "" -"Read into *buffer* a complete message of byte data sent from the other end of the connection and return the " -"number of bytes in the message. Blocks until there is something to receive. Raises :exc:`EOFError` if there is " +"Read into *buffer* a complete message of byte data sent from the other end " +"of the connection and return the number of bytes in the message. Blocks " +"until there is something to receive. Raises :exc:`EOFError` if there is " "nothing left to receive and the other end was closed." msgstr "" -"Lit et stocke dans *buffer* un message complet de données binaires envoyées depuis l'autre bout de la connexion " -"et renvoie le nombre d'octets du message. Bloque jusqu'à ce qu'il y ait quelque chose à recevoir. Lève une :exc:" -"`EOFError` s'il ne reste rien à recevoir et que l'autre côté de la connexion a été fermé." +"Lit et stocke dans *buffer* un message complet de données binaires envoyées " +"depuis l'autre bout de la connexion et renvoie le nombre d'octets du " +"message. Bloque jusqu'à ce qu'il y ait quelque chose à recevoir. Lève une :" +"exc:`EOFError` s'il ne reste rien à recevoir et que l'autre côté de la " +"connexion a été fermé." #: library/multiprocessing.rst:1151 msgid "" -"*buffer* must be a writable :term:`bytes-like object`. If *offset* is given then the message will be written " -"into the buffer from that position. Offset must be a non-negative integer less than the length of *buffer* (in " -"bytes)." +"*buffer* must be a writable :term:`bytes-like object`. If *offset* is given " +"then the message will be written into the buffer from that position. Offset " +"must be a non-negative integer less than the length of *buffer* (in bytes)." msgstr "" -"*buffer* doit être un :term:`bytes-like object` accessible en écriture. Si *offset* est donné, le message sera " -"écrit dans le tampon à partir de cette position. *offset* doit être un entier positif, inférieur à la taille de " +"*buffer* doit être un :term:`bytes-like object` accessible en écriture. Si " +"*offset* est donné, le message sera écrit dans le tampon à partir de cette " +"position. *offset* doit être un entier positif, inférieur à la taille de " "*buffer* (en octets)." #: library/multiprocessing.rst:1156 msgid "" -"If the buffer is too short then a :exc:`BufferTooShort` exception is raised and the complete message is available " -"as ``e.args[0]`` where ``e`` is the exception instance." +"If the buffer is too short then a :exc:`BufferTooShort` exception is raised " +"and the complete message is available as ``e.args[0]`` where ``e`` is the " +"exception instance." msgstr "" -"Si le tampon est trop petit une exception :exc:`BufferTooShort` est levée et le message complet est accessible " -"via ``e.args[0]`` où ``e`` est l'instance de l'exception." +"Si le tampon est trop petit une exception :exc:`BufferTooShort` est levée et " +"le message complet est accessible via ``e.args[0]`` où ``e`` est l'instance " +"de l'exception." #: library/multiprocessing.rst:1160 msgid "" -"Connection objects themselves can now be transferred between processes using :meth:`Connection.send` and :meth:" -"`Connection.recv`." +"Connection objects themselves can now be transferred between processes " +"using :meth:`Connection.send` and :meth:`Connection.recv`." msgstr "" -"Les objets de connexions eux-mêmes peuvent maintenant être transférés entre les processus en utilisant :meth:" -"`Connection.send` et :meth:`Connection.recv`." +"Les objets de connexions eux-mêmes peuvent maintenant être transférés entre " +"les processus en utilisant :meth:`Connection.send` et :meth:`Connection." +"recv`." #: library/multiprocessing.rst:1164 msgid "" -"Connection objects now support the context management protocol -- see :ref:`typecontextmanager`. :meth:" -"`~contextmanager.__enter__` returns the connection object, and :meth:`~contextmanager.__exit__` calls :meth:" -"`close`." +"Connection objects now support the context management protocol -- see :ref:" +"`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the " +"connection object, and :meth:`~contextmanager.__exit__` calls :meth:`close`." msgstr "" -"Les objets de connexions supportent maintenant le protocole des gestionnaires de contexte – voir :ref:" -"`typecontextmanager`. :meth:`~contextmanager.__enter__` renvoie l'objet de connexion, et :meth:`~contextmanager." -"__exit__` appelle :meth:`close`." +"Les objets de connexions supportent maintenant le protocole des " +"gestionnaires de contexte – voir :ref:`typecontextmanager`. :meth:" +"`~contextmanager.__enter__` renvoie l'objet de connexion, et :meth:" +"`~contextmanager.__exit__` appelle :meth:`close`." #: library/multiprocessing.rst:1169 msgid "For example:" @@ -1455,29 +1776,35 @@ msgstr "Par exemple :" #: library/multiprocessing.rst:1193 msgid "" -"The :meth:`Connection.recv` method automatically unpickles the data it receives, which can be a security risk " -"unless you can trust the process which sent the message." +"The :meth:`Connection.recv` method automatically unpickles the data it " +"receives, which can be a security risk unless you can trust the process " +"which sent the message." msgstr "" -"La méthode :meth:`Connection.recv` désérialise automatiquement les données qu'elle reçoit, ce qui peut être un " -"risque de sécurité à moins que vous ne fassiez réellement confiance au processus émetteur du message." +"La méthode :meth:`Connection.recv` désérialise automatiquement les données " +"qu'elle reçoit, ce qui peut être un risque de sécurité à moins que vous ne " +"fassiez réellement confiance au processus émetteur du message." #: library/multiprocessing.rst:1197 msgid "" -"Therefore, unless the connection object was produced using :func:`Pipe` you should only use the :meth:" -"`~Connection.recv` and :meth:`~Connection.send` methods after performing some sort of authentication. See :ref:" +"Therefore, unless the connection object was produced using :func:`Pipe` you " +"should only use the :meth:`~Connection.recv` and :meth:`~Connection.send` " +"methods after performing some sort of authentication. See :ref:" "`multiprocessing-auth-keys`." msgstr "" -"Par conséquent, à moins que l'objet de connexion soit instancié par :func:`Pipe`, vous ne devriez uniquement " -"utiliser les méthodes :meth:`~Connection.recv` et :meth:`~Connection.send` après avoir effectué une quelconque " -"forme d'authentification. Voir :ref:`multiprocessing-auth-keys`." +"Par conséquent, à moins que l'objet de connexion soit instancié par :func:" +"`Pipe`, vous ne devriez uniquement utiliser les méthodes :meth:`~Connection." +"recv` et :meth:`~Connection.send` après avoir effectué une quelconque forme " +"d'authentification. Voir :ref:`multiprocessing-auth-keys`." #: library/multiprocessing.rst:1204 msgid "" -"If a process is killed while it is trying to read or write to a pipe then the data in the pipe is likely to " -"become corrupted, because it may become impossible to be sure where the message boundaries lie." +"If a process is killed while it is trying to read or write to a pipe then " +"the data in the pipe is likely to become corrupted, because it may become " +"impossible to be sure where the message boundaries lie." msgstr "" -"Si un processus est tué pendant qu'il essaye de lire ou écrire sur le tube, alors les données du tube ont des " -"chances d'être corrompues, parce qu'il devient impossible d'être sûr d'où se trouvent les bornes du message." +"Si un processus est tué pendant qu'il essaye de lire ou écrire sur le tube, " +"alors les données du tube ont des chances d'être corrompues, parce qu'il " +"devient impossible d'être sûr d'où se trouvent les bornes du message." #: library/multiprocessing.rst:1210 msgid "Synchronization primitives" @@ -1485,53 +1812,63 @@ msgstr "Primitives de synchronisation" #: library/multiprocessing.rst:1214 msgid "" -"Generally synchronization primitives are not as necessary in a multiprocess program as they are in a " -"multithreaded program. See the documentation for :mod:`threading` module." +"Generally synchronization primitives are not as necessary in a multiprocess " +"program as they are in a multithreaded program. See the documentation for :" +"mod:`threading` module." msgstr "" -"Généralement les primitives de synchronisation ne sont pas nécessaire dans un programme multi-processus comme " -"elles le sont dans un programme multi-fils d'exécution. Voir la documentation du module :mod:`threading`." +"Généralement les primitives de synchronisation ne sont pas nécessaire dans " +"un programme multi-processus comme elles le sont dans un programme multi-" +"fils d'exécution. Voir la documentation du module :mod:`threading`." #: library/multiprocessing.rst:1218 msgid "" -"Note that one can also create synchronization primitives by using a manager object -- see :ref:`multiprocessing-" -"managers`." +"Note that one can also create synchronization primitives by using a manager " +"object -- see :ref:`multiprocessing-managers`." msgstr "" -"Notez que vous pouvez aussi créer des primitives de synchronisation en utilisant un objet gestionnaire – voir :" -"ref:`multiprocessing-managers`." +"Notez que vous pouvez aussi créer des primitives de synchronisation en " +"utilisant un objet gestionnaire – voir :ref:`multiprocessing-managers`." #: library/multiprocessing.rst:1223 msgid "A barrier object: a clone of :class:`threading.Barrier`." msgstr "Un objet barrière : un clone de :class:`threading.Barrier`." #: library/multiprocessing.rst:1229 -msgid "A bounded semaphore object: a close analog of :class:`threading.BoundedSemaphore`." -msgstr "Un objet sémaphore lié : un analogue proche de :class:`threading.BoundedSemaphore`." +msgid "" +"A bounded semaphore object: a close analog of :class:`threading." +"BoundedSemaphore`." +msgstr "" +"Un objet sémaphore lié : un analogue proche de :class:`threading." +"BoundedSemaphore`." #: library/multiprocessing.rst:1232 library/multiprocessing.rst:1370 msgid "" -"A solitary difference from its close analog exists: its ``acquire`` method's first argument is named *block*, as " -"is consistent with :meth:`Lock.acquire`." +"A solitary difference from its close analog exists: its ``acquire`` method's " +"first argument is named *block*, as is consistent with :meth:`Lock.acquire`." msgstr "" -"Une seule différence existe avec son proche analogue : le premier argument de sa méthode ``acquire`` est appelé " -"*block*, pour la cohérence avec :meth:`Lock.acquire`." +"Une seule différence existe avec son proche analogue : le premier argument " +"de sa méthode ``acquire`` est appelé *block*, pour la cohérence avec :meth:" +"`Lock.acquire`." #: library/multiprocessing.rst:1236 msgid "" -"On Mac OS X, this is indistinguishable from :class:`Semaphore` because ``sem_getvalue()`` is not implemented on " -"that platform." +"On Mac OS X, this is indistinguishable from :class:`Semaphore` because " +"``sem_getvalue()`` is not implemented on that platform." msgstr "" -"Sur Mac OS X, elle n'est pas distinguable de la classe :class:`Semaphore` parce que ``sem_getvalue()`` n'est pas " -"implémentée sur cette plateforme." +"Sur Mac OS X, elle n'est pas distinguable de la classe :class:`Semaphore` " +"parce que ``sem_getvalue()`` n'est pas implémentée sur cette plateforme." #: library/multiprocessing.rst:1241 msgid "A condition variable: an alias for :class:`threading.Condition`." -msgstr "Une variable conditionnelle : un alias pour :class:`threading.Condition`." +msgstr "" +"Une variable conditionnelle : un alias pour :class:`threading.Condition`." #: library/multiprocessing.rst:1243 msgid "" -"If *lock* is specified then it should be a :class:`Lock` or :class:`RLock` object from :mod:`multiprocessing`." +"If *lock* is specified then it should be a :class:`Lock` or :class:`RLock` " +"object from :mod:`multiprocessing`." msgstr "" -"Si *lock* est spécifié il doit être un objet :class:`Lock` ou :class:`RLock` du module :mod:`multiprocessing`." +"Si *lock* est spécifié il doit être un objet :class:`Lock` ou :class:`RLock` " +"du module :mod:`multiprocessing`." #: library/multiprocessing.rst:1246 library/multiprocessing.rst:1780 msgid "The :meth:`~threading.Condition.wait_for` method was added." @@ -1543,32 +1880,40 @@ msgstr "Un clone de :class:`threading.Event`." #: library/multiprocessing.rst:1256 msgid "" -"A non-recursive lock object: a close analog of :class:`threading.Lock`. Once a process or thread has acquired a " -"lock, subsequent attempts to acquire it from any process or thread will block until it is released; any process " -"or thread may release it. The concepts and behaviors of :class:`threading.Lock` as it applies to threads are " -"replicated here in :class:`multiprocessing.Lock` as it applies to either processes or threads, except as noted." -msgstr "" -"Un verrou non récursif : un analogue proche de :class:`threading.Lock`. Une fois que le processus ou le fil " -"d'exécution a acquis un verrou, les tentatives suivantes d'acquisition depuis n'importe quel processus ou fil " -"d'exécution bloqueront jusqu'à ce qu'il soit libéré ; n'importe quel processus ou fil peut le libérer. Les " -"concepts et comportements de :class:`threading.Lock` qui s'appliquent aux fils d'exécution sont répliqués ici " -"dans :class:`multiprocessing.Lock` et s'appliquent aux processus et aux fils d'exécution, à l'exception de ce qui " -"est indiqué." +"A non-recursive lock object: a close analog of :class:`threading.Lock`. Once " +"a process or thread has acquired a lock, subsequent attempts to acquire it " +"from any process or thread will block until it is released; any process or " +"thread may release it. The concepts and behaviors of :class:`threading." +"Lock` as it applies to threads are replicated here in :class:" +"`multiprocessing.Lock` as it applies to either processes or threads, except " +"as noted." +msgstr "" +"Un verrou non récursif : un analogue proche de :class:`threading.Lock`. Une " +"fois que le processus ou le fil d'exécution a acquis un verrou, les " +"tentatives suivantes d'acquisition depuis n'importe quel processus ou fil " +"d'exécution bloqueront jusqu'à ce qu'il soit libéré ; n'importe quel " +"processus ou fil peut le libérer. Les concepts et comportements de :class:" +"`threading.Lock` qui s'appliquent aux fils d'exécution sont répliqués ici " +"dans :class:`multiprocessing.Lock` et s'appliquent aux processus et aux fils " +"d'exécution, à l'exception de ce qui est indiqué." #: library/multiprocessing.rst:1264 msgid "" -"Note that :class:`Lock` is actually a factory function which returns an instance of ``multiprocessing.synchronize." -"Lock`` initialized with a default context." +"Note that :class:`Lock` is actually a factory function which returns an " +"instance of ``multiprocessing.synchronize.Lock`` initialized with a default " +"context." msgstr "" -"Notez que :class:`Lock` est en fait une fonction *factory* qui renvoie une instance de ``multiprocessing." -"synchronize.Lock`` initialisée avec un contexte par défaut." +"Notez que :class:`Lock` est en fait une fonction *factory* qui renvoie une " +"instance de ``multiprocessing.synchronize.Lock`` initialisée avec un " +"contexte par défaut." #: library/multiprocessing.rst:1268 msgid "" -":class:`Lock` supports the :term:`context manager` protocol and thus may be used in :keyword:`with` statements." +":class:`Lock` supports the :term:`context manager` protocol and thus may be " +"used in :keyword:`with` statements." msgstr "" -":class:`Lock` supporte le protocole :term:`context manager` et peut ainsi être utilisé avec une instruction :" -"keyword:`with`." +":class:`Lock` supporte le protocole :term:`context manager` et peut ainsi " +"être utilisé avec une instruction :keyword:`with`." #: library/multiprocessing.rst:1273 library/multiprocessing.rst:1324 msgid "Acquire a lock, blocking or non-blocking." @@ -1576,144 +1921,178 @@ msgstr "Acquiert un verrou, bloquant ou non bloquant." #: library/multiprocessing.rst:1275 msgid "" -"With the *block* argument set to ``True`` (the default), the method call will block until the lock is in an " -"unlocked state, then set it to locked and return ``True``. Note that the name of this first argument differs " -"from that in :meth:`threading.Lock.acquire`." +"With the *block* argument set to ``True`` (the default), the method call " +"will block until the lock is in an unlocked state, then set it to locked and " +"return ``True``. Note that the name of this first argument differs from " +"that in :meth:`threading.Lock.acquire`." msgstr "" -"Avec l'argument *block* à ``True`` (par défaut), l'appel de méthode bloquera jusqu'à ce que le verrou soit dans " -"déverrouillé, puis le verrouillera avant de renvoyer ``True``. Notez que le nom de ce premier argument diffère de " +"Avec l'argument *block* à ``True`` (par défaut), l'appel de méthode bloquera " +"jusqu'à ce que le verrou soit dans déverrouillé, puis le verrouillera avant " +"de renvoyer ``True``. Notez que le nom de ce premier argument diffère de " "celui de :meth:`threading.Lock.acquire`." #: library/multiprocessing.rst:1280 msgid "" -"With the *block* argument set to ``False``, the method call does not block. If the lock is currently in a locked " -"state, return ``False``; otherwise set the lock to a locked state and return ``True``." +"With the *block* argument set to ``False``, the method call does not block. " +"If the lock is currently in a locked state, return ``False``; otherwise set " +"the lock to a locked state and return ``True``." msgstr "" -"Avec l'argument *block* à ``False``, l'appel de méthode ne bloque pas. Si le verrou est actuellement verrouillé, " -"renvoie ``False`` ; autrement verrouille le verrou et renvoie ``True``." +"Avec l'argument *block* à ``False``, l'appel de méthode ne bloque pas. Si le " +"verrou est actuellement verrouillé, renvoie ``False`` ; autrement verrouille " +"le verrou et renvoie ``True``." #: library/multiprocessing.rst:1284 msgid "" -"When invoked with a positive, floating-point value for *timeout*, block for at most the number of seconds " -"specified by *timeout* as long as the lock can not be acquired. Invocations with a negative value for *timeout* " -"are equivalent to a *timeout* of zero. Invocations with a *timeout* value of ``None`` (the default) set the " -"timeout period to infinite. Note that the treatment of negative or ``None`` values for *timeout* differs from " -"the implemented behavior in :meth:`threading.Lock.acquire`. The *timeout* argument has no practical implications " -"if the *block* argument is set to ``False`` and is thus ignored. Returns ``True`` if the lock has been acquired " -"or ``False`` if the timeout period has elapsed." -msgstr "" -"Quand invoqué avec un nombre flottant positif comme *timeout*, bloque au maximum pendant ce nombre spécifié de " -"secondes, tant que le verrou ne peut être acquis. Les invocations avec une valeur de *timeout* négatives sont " -"équivalents à zéro. Les invocations avec un *timeout* à ``None`` (par défaut) correspondent à un délai d'attente " -"infini. Notez que le traitement des valeurs de *timeout* négatives et ``None`` diffère du comportement implémenté " -"dans :meth:`threading.Lock.acquire`. L'argument *timeout* n'a pas d'implication pratique si l'argument *block* " -"est mis ) ``False`` et est alors ignoré. Renvoie ``True`` si le verrou a été acquis et ``False`` si le temps de " -"*timeout* a expiré." +"When invoked with a positive, floating-point value for *timeout*, block for " +"at most the number of seconds specified by *timeout* as long as the lock can " +"not be acquired. Invocations with a negative value for *timeout* are " +"equivalent to a *timeout* of zero. Invocations with a *timeout* value of " +"``None`` (the default) set the timeout period to infinite. Note that the " +"treatment of negative or ``None`` values for *timeout* differs from the " +"implemented behavior in :meth:`threading.Lock.acquire`. The *timeout* " +"argument has no practical implications if the *block* argument is set to " +"``False`` and is thus ignored. Returns ``True`` if the lock has been " +"acquired or ``False`` if the timeout period has elapsed." +msgstr "" +"Quand invoqué avec un nombre flottant positif comme *timeout*, bloque au " +"maximum pendant ce nombre spécifié de secondes, tant que le verrou ne peut " +"être acquis. Les invocations avec une valeur de *timeout* négatives sont " +"équivalents à zéro. Les invocations avec un *timeout* à ``None`` (par " +"défaut) correspondent à un délai d'attente infini. Notez que le traitement " +"des valeurs de *timeout* négatives et ``None`` diffère du comportement " +"implémenté dans :meth:`threading.Lock.acquire`. L'argument *timeout* n'a pas " +"d'implication pratique si l'argument *block* est mis ) ``False`` et est " +"alors ignoré. Renvoie ``True`` si le verrou a été acquis et ``False`` si le " +"temps de *timeout* a expiré." #: library/multiprocessing.rst:1299 msgid "" -"Release a lock. This can be called from any process or thread, not only the process or thread which originally " -"acquired the lock." +"Release a lock. This can be called from any process or thread, not only the " +"process or thread which originally acquired the lock." msgstr "" -"Libère un verrou. Elle peut être appelée depuis n'importe quel processus ou fil d'exécution, pas uniquement le " -"processus ou le fil qui a acquis le verrou à l'origine." +"Libère un verrou. Elle peut être appelée depuis n'importe quel processus ou " +"fil d'exécution, pas uniquement le processus ou le fil qui a acquis le " +"verrou à l'origine." #: library/multiprocessing.rst:1302 msgid "" -"Behavior is the same as in :meth:`threading.Lock.release` except that when invoked on an unlocked lock, a :exc:" -"`ValueError` is raised." +"Behavior is the same as in :meth:`threading.Lock.release` except that when " +"invoked on an unlocked lock, a :exc:`ValueError` is raised." msgstr "" -"Le comportement est le même que :meth:`threading.Lock.release` excepté que lorsque la méthode est appelée sur un " -"verrou déverrouillé, une :exc:`ValueError` est levée." +"Le comportement est le même que :meth:`threading.Lock.release` excepté que " +"lorsque la méthode est appelée sur un verrou déverrouillé, une :exc:" +"`ValueError` est levée." #: library/multiprocessing.rst:1308 msgid "" -"A recursive lock object: a close analog of :class:`threading.RLock`. A recursive lock must be released by the " -"process or thread that acquired it. Once a process or thread has acquired a recursive lock, the same process or " -"thread may acquire it again without blocking; that process or thread must release it once for each time it has " -"been acquired." +"A recursive lock object: a close analog of :class:`threading.RLock`. A " +"recursive lock must be released by the process or thread that acquired it. " +"Once a process or thread has acquired a recursive lock, the same process or " +"thread may acquire it again without blocking; that process or thread must " +"release it once for each time it has been acquired." msgstr "" -"Un objet verrou récursif : un analogue proche de :class:`threading.RLock`. Un verrou récursif doit être libéré " -"par le processus ou le fil d'exécution qui l'a acquis. Quand un processus ou un fil acquiert un verrou récursif, " -"le même processus/fil peut l'acquérir à nouveau sans bloquer ; le processus/fil doit le libérer autant de fois " -"qu'il l'acquiert." +"Un objet verrou récursif : un analogue proche de :class:`threading.RLock`. " +"Un verrou récursif doit être libéré par le processus ou le fil d'exécution " +"qui l'a acquis. Quand un processus ou un fil acquiert un verrou récursif, le " +"même processus/fil peut l'acquérir à nouveau sans bloquer ; le processus/fil " +"doit le libérer autant de fois qu'il l'acquiert." #: library/multiprocessing.rst:1314 msgid "" -"Note that :class:`RLock` is actually a factory function which returns an instance of ``multiprocessing." -"synchronize.RLock`` initialized with a default context." +"Note that :class:`RLock` is actually a factory function which returns an " +"instance of ``multiprocessing.synchronize.RLock`` initialized with a default " +"context." msgstr "" -"Notez que :class:`RLock` est en fait une fonction *factory* qui renvoie une instance de ``multiprocessing." -"synchronize.RLock`` initialisée avec un contexte par défaut." +"Notez que :class:`RLock` est en fait une fonction *factory* qui renvoie une " +"instance de ``multiprocessing.synchronize.RLock`` initialisée avec un " +"contexte par défaut." #: library/multiprocessing.rst:1318 msgid "" -":class:`RLock` supports the :term:`context manager` protocol and thus may be used in :keyword:`with` statements." +":class:`RLock` supports the :term:`context manager` protocol and thus may be " +"used in :keyword:`with` statements." msgstr "" -":class:`RLock` supporte le protocole :term:`context manager` et peut ainsi être utilisée avec une instruction :" -"keyword:`with`." +":class:`RLock` supporte le protocole :term:`context manager` et peut ainsi " +"être utilisée avec une instruction :keyword:`with`." #: library/multiprocessing.rst:1326 msgid "" -"When invoked with the *block* argument set to ``True``, block until the lock is in an unlocked state (not owned " -"by any process or thread) unless the lock is already owned by the current process or thread. The current process " -"or thread then takes ownership of the lock (if it does not already have ownership) and the recursion level inside " -"the lock increments by one, resulting in a return value of ``True``. Note that there are several differences in " -"this first argument's behavior compared to the implementation of :meth:`threading.RLock.acquire`, starting with " -"the name of the argument itself." -msgstr "" -"Quand invoqué avec l'argument *block* à ``True``, bloque jusqu'à ce que le verrou soit déverrouillé " -"(n'appartenant à aucun processus ou fil d'exécution) sauf s'il appartient déjà au processus ou fil d'exécution " -"courant. Le processus ou fil d'exécution courant prend la possession du verrou (s'il ne l'a pas déjà) et " -"incrémente d'un le niveau de récursion du verrou, renvoyant ainsi ``True``. Notez qu'il y a plusieurs différences " -"dans le comportement de ce premier argument comparé à l'implémentation de :meth:`threading.RLock.acquire`, à " -"commencer par le nom de l'argument lui-même." +"When invoked with the *block* argument set to ``True``, block until the lock " +"is in an unlocked state (not owned by any process or thread) unless the lock " +"is already owned by the current process or thread. The current process or " +"thread then takes ownership of the lock (if it does not already have " +"ownership) and the recursion level inside the lock increments by one, " +"resulting in a return value of ``True``. Note that there are several " +"differences in this first argument's behavior compared to the implementation " +"of :meth:`threading.RLock.acquire`, starting with the name of the argument " +"itself." +msgstr "" +"Quand invoqué avec l'argument *block* à ``True``, bloque jusqu'à ce que le " +"verrou soit déverrouillé (n'appartenant à aucun processus ou fil " +"d'exécution) sauf s'il appartient déjà au processus ou fil d'exécution " +"courant. Le processus ou fil d'exécution courant prend la possession du " +"verrou (s'il ne l'a pas déjà) et incrémente d'un le niveau de récursion du " +"verrou, renvoyant ainsi ``True``. Notez qu'il y a plusieurs différences dans " +"le comportement de ce premier argument comparé à l'implémentation de :meth:" +"`threading.RLock.acquire`, à commencer par le nom de l'argument lui-même." #: library/multiprocessing.rst:1336 msgid "" -"When invoked with the *block* argument set to ``False``, do not block. If the lock has already been acquired (and " -"thus is owned) by another process or thread, the current process or thread does not take ownership and the " -"recursion level within the lock is not changed, resulting in a return value of ``False``. If the lock is in an " -"unlocked state, the current process or thread takes ownership and the recursion level is incremented, resulting " -"in a return value of ``True``." -msgstr "" -"Quand invoqué avec l'argument *block* à ``False``, ne bloque pas. Si le verrou est déjà acquis (et possédé) par " -"un autre processus ou fil d'exécution, le processus/fil courant n'en prend pas la possession et le niveau de " -"récursion n'est pas incrémenté, résultant en une valeur de retour à ``False``. Si le verrou est déverrouillé, le " -"processus/fil courant en prend possession et incrémente son niveau de récursion, renvoyant ``True``." +"When invoked with the *block* argument set to ``False``, do not block. If " +"the lock has already been acquired (and thus is owned) by another process or " +"thread, the current process or thread does not take ownership and the " +"recursion level within the lock is not changed, resulting in a return value " +"of ``False``. If the lock is in an unlocked state, the current process or " +"thread takes ownership and the recursion level is incremented, resulting in " +"a return value of ``True``." +msgstr "" +"Quand invoqué avec l'argument *block* à ``False``, ne bloque pas. Si le " +"verrou est déjà acquis (et possédé) par un autre processus ou fil " +"d'exécution, le processus/fil courant n'en prend pas la possession et le " +"niveau de récursion n'est pas incrémenté, résultant en une valeur de retour " +"à ``False``. Si le verrou est déverrouillé, le processus/fil courant en " +"prend possession et incrémente son niveau de récursion, renvoyant ``True``." #: library/multiprocessing.rst:1344 msgid "" -"Use and behaviors of the *timeout* argument are the same as in :meth:`Lock.acquire`. Note that some of these " -"behaviors of *timeout* differ from the implemented behaviors in :meth:`threading.RLock.acquire`." +"Use and behaviors of the *timeout* argument are the same as in :meth:`Lock." +"acquire`. Note that some of these behaviors of *timeout* differ from the " +"implemented behaviors in :meth:`threading.RLock.acquire`." msgstr "" -"L'usage et les comportements de l'argument *timeout* sont les mêmes que pour :meth:`Lock.acquire`. Notez que " -"certains de ces comportements diffèrent par rapport à ceux implémentés par :meth:`threading.RLock.acquire`." +"L'usage et les comportements de l'argument *timeout* sont les mêmes que " +"pour :meth:`Lock.acquire`. Notez que certains de ces comportements diffèrent " +"par rapport à ceux implémentés par :meth:`threading.RLock.acquire`." #: library/multiprocessing.rst:1351 msgid "" -"Release a lock, decrementing the recursion level. If after the decrement the recursion level is zero, reset the " -"lock to unlocked (not owned by any process or thread) and if any other processes or threads are blocked waiting " -"for the lock to become unlocked, allow exactly one of them to proceed. If after the decrement the recursion " -"level is still nonzero, the lock remains locked and owned by the calling process or thread." -msgstr "" -"Libère un verrou, décrémentant son niveau de récursion. Si après la décrémentation le niveau de récursion est " -"zéro, réinitialise le verrou à un état déverrouillé (n'appartenant à aucun processus ou fil d'exécution) et si " -"des processus/fils attendent que le verrou se déverrouillé, autorise un seul d'entre-eux à continuer. Si après " -"cette décrémentation le niveau de récursion est toujours strictement positif, le verrou reste verrouillé et " +"Release a lock, decrementing the recursion level. If after the decrement " +"the recursion level is zero, reset the lock to unlocked (not owned by any " +"process or thread) and if any other processes or threads are blocked waiting " +"for the lock to become unlocked, allow exactly one of them to proceed. If " +"after the decrement the recursion level is still nonzero, the lock remains " +"locked and owned by the calling process or thread." +msgstr "" +"Libère un verrou, décrémentant son niveau de récursion. Si après la " +"décrémentation le niveau de récursion est zéro, réinitialise le verrou à un " +"état déverrouillé (n'appartenant à aucun processus ou fil d'exécution) et si " +"des processus/fils attendent que le verrou se déverrouillé, autorise un seul " +"d'entre-eux à continuer. Si après cette décrémentation le niveau de " +"récursion est toujours strictement positif, le verrou reste verrouillé et " "propriété du processus/fil appelant." #: library/multiprocessing.rst:1359 msgid "" -"Only call this method when the calling process or thread owns the lock. An :exc:`AssertionError` is raised if " -"this method is called by a process or thread other than the owner or if the lock is in an unlocked (unowned) " -"state. Note that the type of exception raised in this situation differs from the implemented behavior in :meth:" -"`threading.RLock.release`." +"Only call this method when the calling process or thread owns the lock. An :" +"exc:`AssertionError` is raised if this method is called by a process or " +"thread other than the owner or if the lock is in an unlocked (unowned) " +"state. Note that the type of exception raised in this situation differs " +"from the implemented behavior in :meth:`threading.RLock.release`." msgstr "" -"N'appelez cette méthode que si le processus ou fil d'exécution appelant est propriétaire du verrou. Une :exc:" -"`AssertionError` est levée si cette méthode est appelée par un processus/fil autre que le propriétaire ou si le " -"verrou n'est pas verrouillé (possédé). Notez que le type d'exception levé dans cette situation diffère du " -"comportement de :meth:`threading.RLock.release`." +"N'appelez cette méthode que si le processus ou fil d'exécution appelant est " +"propriétaire du verrou. Une :exc:`AssertionError` est levée si cette méthode " +"est appelée par un processus/fil autre que le propriétaire ou si le verrou " +"n'est pas verrouillé (possédé). Notez que le type d'exception levé dans " +"cette situation diffère du comportement de :meth:`threading.RLock.release`." #: library/multiprocessing.rst:1368 msgid "A semaphore object: a close analog of :class:`threading.Semaphore`." @@ -1721,131 +2100,161 @@ msgstr "Un objet sémaphore, proche analogue de :class:`threading.Semaphore`." #: library/multiprocessing.rst:1375 msgid "" -"On Mac OS X, ``sem_timedwait`` is unsupported, so calling ``acquire()`` with a timeout will emulate that " -"function's behavior using a sleeping loop." +"On Mac OS X, ``sem_timedwait`` is unsupported, so calling ``acquire()`` with " +"a timeout will emulate that function's behavior using a sleeping loop." msgstr "" -"Sous Mac OS X, ``sem_timedwait`` n'est pas supporté, donc appeler ``acquire()`` avec un temps d'exécution limité " -"émulera le comportement de cette fonction en utilisant une boucle d'attente." +"Sous Mac OS X, ``sem_timedwait`` n'est pas supporté, donc appeler " +"``acquire()`` avec un temps d'exécution limité émulera le comportement de " +"cette fonction en utilisant une boucle d'attente." #: library/multiprocessing.rst:1380 msgid "" -"If the SIGINT signal generated by :kbd:`Ctrl-C` arrives while the main thread is blocked by a call to :meth:" -"`BoundedSemaphore.acquire`, :meth:`Lock.acquire`, :meth:`RLock.acquire`, :meth:`Semaphore.acquire`, :meth:" -"`Condition.acquire` or :meth:`Condition.wait` then the call will be immediately interrupted and :exc:" -"`KeyboardInterrupt` will be raised." +"If the SIGINT signal generated by :kbd:`Ctrl-C` arrives while the main " +"thread is blocked by a call to :meth:`BoundedSemaphore.acquire`, :meth:`Lock." +"acquire`, :meth:`RLock.acquire`, :meth:`Semaphore.acquire`, :meth:`Condition." +"acquire` or :meth:`Condition.wait` then the call will be immediately " +"interrupted and :exc:`KeyboardInterrupt` will be raised." msgstr "" -"Si le signal *SIGINT* généré par un :kbd:`Ctrl-C` survient pendant que le fil d'exécution principal est bloqué " -"par un appel à :meth:`BoundedSemaphore.acquire`, :meth:`Lock.acquire`, :meth:`RLock.acquire`, :meth:`Semaphore." -"acquire`, :meth:`Condition.acquire` ou :meth:`Condition.wait`, l'appel sera immédiatement interrompu et une :exc:" -"`KeyboardInterrupt` sera levée." +"Si le signal *SIGINT* généré par un :kbd:`Ctrl-C` survient pendant que le " +"fil d'exécution principal est bloqué par un appel à :meth:`BoundedSemaphore." +"acquire`, :meth:`Lock.acquire`, :meth:`RLock.acquire`, :meth:`Semaphore." +"acquire`, :meth:`Condition.acquire` ou :meth:`Condition.wait`, l'appel sera " +"immédiatement interrompu et une :exc:`KeyboardInterrupt` sera levée." #: library/multiprocessing.rst:1386 msgid "" -"This differs from the behaviour of :mod:`threading` where SIGINT will be ignored while the equivalent blocking " -"calls are in progress." +"This differs from the behaviour of :mod:`threading` where SIGINT will be " +"ignored while the equivalent blocking calls are in progress." msgstr "" -"Cela diffère du comportement de :mod:`threading` où le *SIGINT* est ignoré tant que les appels bloquants sont en " -"cours." +"Cela diffère du comportement de :mod:`threading` où le *SIGINT* est ignoré " +"tant que les appels bloquants sont en cours." #: library/multiprocessing.rst:1391 msgid "" -"Some of this package's functionality requires a functioning shared semaphore implementation on the host operating " -"system. Without one, the :mod:`multiprocessing.synchronize` module will be disabled, and attempts to import it " -"will result in an :exc:`ImportError`. See :issue:`3770` for additional information." +"Some of this package's functionality requires a functioning shared semaphore " +"implementation on the host operating system. Without one, the :mod:" +"`multiprocessing.synchronize` module will be disabled, and attempts to " +"import it will result in an :exc:`ImportError`. See :issue:`3770` for " +"additional information." msgstr "" -"Certaines des fonctionnalités de ce paquet requièrent une implémentation fonctionnelle de sémaphores partagés sur " -"le système hôte. Sans cela, le module :mod:`multiprocessing.synchronize` sera désactivé, et les tentatives de " -"l'importer lèveront une :exc:`ImportError`. Voir :issue:`3770` pour plus d'informations." +"Certaines des fonctionnalités de ce paquet requièrent une implémentation " +"fonctionnelle de sémaphores partagés sur le système hôte. Sans cela, le " +"module :mod:`multiprocessing.synchronize` sera désactivé, et les tentatives " +"de l'importer lèveront une :exc:`ImportError`. Voir :issue:`3770` pour plus " +"d'informations." #: library/multiprocessing.rst:1399 msgid "Shared :mod:`ctypes` Objects" msgstr "Objets :mod:`ctypes` partagés" #: library/multiprocessing.rst:1401 -msgid "It is possible to create shared objects using shared memory which can be inherited by child processes." +msgid "" +"It is possible to create shared objects using shared memory which can be " +"inherited by child processes." msgstr "" -"Il est possible de créer des objets partagés utilisant une mémoire partagée pouvant être héritée par les " -"processus enfants." +"Il est possible de créer des objets partagés utilisant une mémoire partagée " +"pouvant être héritée par les processus enfants." #: library/multiprocessing.rst:1406 msgid "" -"Return a :mod:`ctypes` object allocated from shared memory. By default the return value is actually a " -"synchronized wrapper for the object. The object itself can be accessed via the *value* attribute of a :class:" -"`Value`." +"Return a :mod:`ctypes` object allocated from shared memory. By default the " +"return value is actually a synchronized wrapper for the object. The object " +"itself can be accessed via the *value* attribute of a :class:`Value`." msgstr "" -"Renvoie un objet :mod:`ctypes` alloué depuis la mémoire partagée. Par défaut la valeur de retour est en fait un " -"*wrapper* synchronisé autour de l'objet. L'objet en lui-même est accessible par l'attribut *value* de l'une :" -"class:`Value`." +"Renvoie un objet :mod:`ctypes` alloué depuis la mémoire partagée. Par défaut " +"la valeur de retour est en fait un *wrapper* synchronisé autour de l'objet. " +"L'objet en lui-même est accessible par l'attribut *value* de l'une :class:" +"`Value`." #: library/multiprocessing.rst:1410 library/multiprocessing.rst:1497 msgid "" -"*typecode_or_type* determines the type of the returned object: it is either a ctypes type or a one character " -"typecode of the kind used by the :mod:`array` module. *\\*args* is passed on to the constructor for the type." +"*typecode_or_type* determines the type of the returned object: it is either " +"a ctypes type or a one character typecode of the kind used by the :mod:" +"`array` module. *\\*args* is passed on to the constructor for the type." msgstr "" -"*typecode_or_type* détermine le type de l'objet renvoyé : il s'agit soit d'un type *ctype* soit d'un caractère " -"*typecode* tel qu'utilisé par le module :mod:`array`. *\\*args* est passé au constructeur de ce type." +"*typecode_or_type* détermine le type de l'objet renvoyé : il s'agit soit " +"d'un type *ctype* soit d'un caractère *typecode* tel qu'utilisé par le " +"module :mod:`array`. *\\*args* est passé au constructeur de ce type." #: library/multiprocessing.rst:1414 msgid "" -"If *lock* is ``True`` (the default) then a new recursive lock object is created to synchronize access to the " -"value. If *lock* is a :class:`Lock` or :class:`RLock` object then that will be used to synchronize access to the " -"value. If *lock* is ``False`` then access to the returned object will not be automatically protected by a lock, " -"so it will not necessarily be \"process-safe\"." +"If *lock* is ``True`` (the default) then a new recursive lock object is " +"created to synchronize access to the value. If *lock* is a :class:`Lock` " +"or :class:`RLock` object then that will be used to synchronize access to the " +"value. If *lock* is ``False`` then access to the returned object will not " +"be automatically protected by a lock, so it will not necessarily be " +"\"process-safe\"." msgstr "" -"Si *lock* vaut ``True`` (par défaut), alors un nouveau verrou récursif est créé pour synchroniser l'accès à la " -"valeur. Si *lock* est un objet :class:`Lock` ou :class:`RLock` alors il sera utilisé pour synchroniser l'accès à " -"la valeur. Si *lock* vaut ``False``, l'accès à l'objet renvoyé ne sera pas automatiquement protégé par un verrou, " -"donc il ne sera pas forcément « *process-safe* »." +"Si *lock* vaut ``True`` (par défaut), alors un nouveau verrou récursif est " +"créé pour synchroniser l'accès à la valeur. Si *lock* est un objet :class:" +"`Lock` ou :class:`RLock` alors il sera utilisé pour synchroniser l'accès à " +"la valeur. Si *lock* vaut ``False``, l'accès à l'objet renvoyé ne sera pas " +"automatiquement protégé par un verrou, donc il ne sera pas forcément " +"« *process-safe* »." #: library/multiprocessing.rst:1421 msgid "" -"Operations like ``+=`` which involve a read and write are not atomic. So if, for instance, you want to " -"atomically increment a shared value it is insufficient to just do ::" +"Operations like ``+=`` which involve a read and write are not atomic. So " +"if, for instance, you want to atomically increment a shared value it is " +"insufficient to just do ::" msgstr "" -"Les opérations telles que ``+=`` qui impliquent une lecture et une écriture ne sont pas atomique. Ainsi si vous " -"souhaitez par exemple réaliser une incrémentation atomique sur une valeur partagée, vous ne pouvez pas simplement " -"faire ::" +"Les opérations telles que ``+=`` qui impliquent une lecture et une écriture " +"ne sont pas atomique. Ainsi si vous souhaitez par exemple réaliser une " +"incrémentation atomique sur une valeur partagée, vous ne pouvez pas " +"simplement faire ::" #: library/multiprocessing.rst:1427 -msgid "Assuming the associated lock is recursive (which it is by default) you can instead do ::" +msgid "" +"Assuming the associated lock is recursive (which it is by default) you can " +"instead do ::" msgstr "" -"En supposant que le verrou associé est récursif (ce qui est le cas par défaut), vous pouvez à la place faire ::" +"En supposant que le verrou associé est récursif (ce qui est le cas par " +"défaut), vous pouvez à la place faire ::" -#: library/multiprocessing.rst:1433 library/multiprocessing.rst:1523 library/multiprocessing.rst:1538 +#: library/multiprocessing.rst:1433 library/multiprocessing.rst:1523 +#: library/multiprocessing.rst:1538 msgid "Note that *lock* is a keyword-only argument." msgstr "Notez que *lock* est un argument *keyword-only*." #: library/multiprocessing.rst:1437 msgid "" -"Return a ctypes array allocated from shared memory. By default the return value is actually a synchronized " -"wrapper for the array." +"Return a ctypes array allocated from shared memory. By default the return " +"value is actually a synchronized wrapper for the array." msgstr "" -"Renvoie un tableau *ctypes* alloué depuis la mémoire partagée. Par défaut la valeur de retour est en fait un " -"*wrapper* synchronisé autour du tableau." +"Renvoie un tableau *ctypes* alloué depuis la mémoire partagée. Par défaut la " +"valeur de retour est en fait un *wrapper* synchronisé autour du tableau." #: library/multiprocessing.rst:1440 msgid "" -"*typecode_or_type* determines the type of the elements of the returned array: it is either a ctypes type or a one " -"character typecode of the kind used by the :mod:`array` module. If *size_or_initializer* is an integer, then it " -"determines the length of the array, and the array will be initially zeroed. Otherwise, *size_or_initializer* is a " -"sequence which is used to initialize the array and whose length determines the length of the array." +"*typecode_or_type* determines the type of the elements of the returned " +"array: it is either a ctypes type or a one character typecode of the kind " +"used by the :mod:`array` module. If *size_or_initializer* is an integer, " +"then it determines the length of the array, and the array will be initially " +"zeroed. Otherwise, *size_or_initializer* is a sequence which is used to " +"initialize the array and whose length determines the length of the array." msgstr "" -"*typecode_or_type* détermine le type des éléments du tableau renvoyé : il s'agit soit d'un type *ctype* soit d'un " -"caractère *typecode* tel qu'utilisé par le module :mod:`array`. Si *size_or_initialize* est un entier, alors il " -"détermine la taille du tableau, et le tableau sera initialisé avec des zéros. Autrement, *size*or_initializer* " -"est une séquence qui sera utilisée pour initialiser le tableau et dont la taille détermine celle du tableau." +"*typecode_or_type* détermine le type des éléments du tableau renvoyé : il " +"s'agit soit d'un type *ctype* soit d'un caractère *typecode* tel qu'utilisé " +"par le module :mod:`array`. Si *size_or_initialize* est un entier, alors il " +"détermine la taille du tableau, et le tableau sera initialisé avec des " +"zéros. Autrement, *size*or_initializer* est une séquence qui sera utilisée " +"pour initialiser le tableau et dont la taille détermine celle du tableau." #: library/multiprocessing.rst:1447 msgid "" -"If *lock* is ``True`` (the default) then a new lock object is created to synchronize access to the value. If " -"*lock* is a :class:`Lock` or :class:`RLock` object then that will be used to synchronize access to the value. If " -"*lock* is ``False`` then access to the returned object will not be automatically protected by a lock, so it will " -"not necessarily be \"process-safe\"." +"If *lock* is ``True`` (the default) then a new lock object is created to " +"synchronize access to the value. If *lock* is a :class:`Lock` or :class:" +"`RLock` object then that will be used to synchronize access to the value. " +"If *lock* is ``False`` then access to the returned object will not be " +"automatically protected by a lock, so it will not necessarily be \"process-" +"safe\"." msgstr "" -"Si *lock* vaut ``True`` (par défaut), alors un nouveau verrou est créé pour synchroniser l'accès à la valeur. Si " -"*lock* est un objet :class:`Lock` ou :class:`RLock` alors il sera utilisé pour synchroniser l'accès à la valeur. " -"Si *lock* vaut ``False``, l'accès à l'objet renvoyé ne sera pas automatiquement protégé par un verrou, donc il ne " -"sera pas forcément « *process-safe* »." +"Si *lock* vaut ``True`` (par défaut), alors un nouveau verrou est créé pour " +"synchroniser l'accès à la valeur. Si *lock* est un objet :class:`Lock` ou :" +"class:`RLock` alors il sera utilisé pour synchroniser l'accès à la valeur. " +"Si *lock* vaut ``False``, l'accès à l'objet renvoyé ne sera pas " +"automatiquement protégé par un verrou, donc il ne sera pas forcément " +"« *process-safe* »." #: library/multiprocessing.rst:1454 msgid "Note that *lock* is a keyword only argument." @@ -1853,11 +2262,12 @@ msgstr "Notez que *lock* est un argument *keyword-only*." #: library/multiprocessing.rst:1456 msgid "" -"Note that an array of :data:`ctypes.c_char` has *value* and *raw* attributes which allow one to use it to store " -"and retrieve strings." +"Note that an array of :data:`ctypes.c_char` has *value* and *raw* attributes " +"which allow one to use it to store and retrieve strings." msgstr "" -"Notez qu'un tableau de :data:`ctypes.c_char` a ses attributs *value* et *raw* qui permettent de l'utiliser pour " -"stocker et récupérer des chaînes de caractères." +"Notez qu'un tableau de :data:`ctypes.c_char` a ses attributs *value* et " +"*raw* qui permettent de l'utiliser pour stocker et récupérer des chaînes de " +"caractères." #: library/multiprocessing.rst:1461 msgid "The :mod:`multiprocessing.sharedctypes` module" @@ -1865,22 +2275,27 @@ msgstr "Le module :mod:`multiprocessing.sharedctypes`" #: library/multiprocessing.rst:1466 msgid "" -"The :mod:`multiprocessing.sharedctypes` module provides functions for allocating :mod:`ctypes` objects from " -"shared memory which can be inherited by child processes." +"The :mod:`multiprocessing.sharedctypes` module provides functions for " +"allocating :mod:`ctypes` objects from shared memory which can be inherited " +"by child processes." msgstr "" -"Le module :mod:`multiprocessing.sharedctypes` fournit des fonctions pour allouer des objets :mod:`ctypes` depuis " -"la mémoire partagée, qui peuvent être hérités par les processus fils." +"Le module :mod:`multiprocessing.sharedctypes` fournit des fonctions pour " +"allouer des objets :mod:`ctypes` depuis la mémoire partagée, qui peuvent " +"être hérités par les processus fils." #: library/multiprocessing.rst:1472 msgid "" -"Although it is possible to store a pointer in shared memory remember that this will refer to a location in the " -"address space of a specific process. However, the pointer is quite likely to be invalid in the context of a " -"second process and trying to dereference the pointer from the second process may cause a crash." +"Although it is possible to store a pointer in shared memory remember that " +"this will refer to a location in the address space of a specific process. " +"However, the pointer is quite likely to be invalid in the context of a " +"second process and trying to dereference the pointer from the second process " +"may cause a crash." msgstr "" -"Bien qu'il soit possible de stocker un pointeur en mémoire partagée, rappelez-vous qu'un pointer référence un " -"emplacement dans l'espace d'adressage d'un processus particulier. Ainsi, ce pointeur a de fortes chances d'être " -"invalide dans le contexte d'un autre processus et déréférencer le pointeur depuis ce second processus peut causer " -"un plantage." +"Bien qu'il soit possible de stocker un pointeur en mémoire partagée, " +"rappelez-vous qu'un pointer référence un emplacement dans l'espace " +"d'adressage d'un processus particulier. Ainsi, ce pointeur a de fortes " +"chances d'être invalide dans le contexte d'un autre processus et " +"déréférencer le pointeur depuis ce second processus peut causer un plantage." #: library/multiprocessing.rst:1480 msgid "Return a ctypes array allocated from shared memory." @@ -1888,24 +2303,30 @@ msgstr "Renvoie un tableau *ctypes* alloué depuis la mémoire partagée." #: library/multiprocessing.rst:1482 msgid "" -"*typecode_or_type* determines the type of the elements of the returned array: it is either a ctypes type or a one " -"character typecode of the kind used by the :mod:`array` module. If *size_or_initializer* is an integer then it " -"determines the length of the array, and the array will be initially zeroed. Otherwise *size_or_initializer* is a " -"sequence which is used to initialize the array and whose length determines the length of the array." -msgstr "" -"*typecode_or_type* détermine le type des éléments du tableau renvoyé : il s'agit soit d'un type *ctype* soit d'un " -"caractère codant le type des éléments du tableau (*typecode*) tel qu'utilisé par le module :mod:`array`. Si " -"*size_or_initialize* est un entier, alors il détermine la taille du tableau, et le tableau sera initialisé avec " -"des zéros. Autrement, *size_or_initializer* est une séquence qui sera utilisée pour initialiser le tableau et " -"dont la taille détermine celle du tableau." +"*typecode_or_type* determines the type of the elements of the returned " +"array: it is either a ctypes type or a one character typecode of the kind " +"used by the :mod:`array` module. If *size_or_initializer* is an integer " +"then it determines the length of the array, and the array will be initially " +"zeroed. Otherwise *size_or_initializer* is a sequence which is used to " +"initialize the array and whose length determines the length of the array." +msgstr "" +"*typecode_or_type* détermine le type des éléments du tableau renvoyé : il " +"s'agit soit d'un type *ctype* soit d'un caractère codant le type des " +"éléments du tableau (*typecode*) tel qu'utilisé par le module :mod:`array`. " +"Si *size_or_initialize* est un entier, alors il détermine la taille du " +"tableau, et le tableau sera initialisé avec des zéros. Autrement, " +"*size_or_initializer* est une séquence qui sera utilisée pour initialiser le " +"tableau et dont la taille détermine celle du tableau." #: library/multiprocessing.rst:1489 msgid "" -"Note that setting and getting an element is potentially non-atomic -- use :func:`Array` instead to make sure that " -"access is automatically synchronized using a lock." +"Note that setting and getting an element is potentially non-atomic -- use :" +"func:`Array` instead to make sure that access is automatically synchronized " +"using a lock." msgstr "" -"Notez que définir ou récupérer un élément est potentiellement non atomique – utilisez plutôt :func:`Array` pour " -"vous assurer de synchroniser automatiquement avec un verrou." +"Notez que définir ou récupérer un élément est potentiellement non atomique – " +"utilisez plutôt :func:`Array` pour vous assurer de synchroniser " +"automatiquement avec un verrou." #: library/multiprocessing.rst:1495 msgid "Return a ctypes object allocated from shared memory." @@ -1913,87 +2334,110 @@ msgstr "Renvoie un objet *ctypes* alloué depuis la mémoire partagée." #: library/multiprocessing.rst:1501 msgid "" -"Note that setting and getting the value is potentially non-atomic -- use :func:`Value` instead to make sure that " -"access is automatically synchronized using a lock." +"Note that setting and getting the value is potentially non-atomic -- use :" +"func:`Value` instead to make sure that access is automatically synchronized " +"using a lock." msgstr "" -"Notez que définir ou récupérer un élément est potentiellement non atomique – utilisez plutôt :func:`Value` pour " -"vous assurer de synchroniser automatiquement avec un verrou." +"Notez que définir ou récupérer un élément est potentiellement non atomique – " +"utilisez plutôt :func:`Value` pour vous assurer de synchroniser " +"automatiquement avec un verrou." #: library/multiprocessing.rst:1505 msgid "" -"Note that an array of :data:`ctypes.c_char` has ``value`` and ``raw`` attributes which allow one to use it to " -"store and retrieve strings -- see documentation for :mod:`ctypes`." +"Note that an array of :data:`ctypes.c_char` has ``value`` and ``raw`` " +"attributes which allow one to use it to store and retrieve strings -- see " +"documentation for :mod:`ctypes`." msgstr "" -"Notez qu'un tableau de :data:`ctypes.c_char` a ses attributs *value* et *raw* qui permettent de l'utiliser pour " -"stocker et récupérer des chaînes de caractères – voir la documentation de :mod:`ctypes`." +"Notez qu'un tableau de :data:`ctypes.c_char` a ses attributs *value* et " +"*raw* qui permettent de l'utiliser pour stocker et récupérer des chaînes de " +"caractères – voir la documentation de :mod:`ctypes`." #: library/multiprocessing.rst:1511 msgid "" -"The same as :func:`RawArray` except that depending on the value of *lock* a process-safe synchronization wrapper " -"may be returned instead of a raw ctypes array." +"The same as :func:`RawArray` except that depending on the value of *lock* a " +"process-safe synchronization wrapper may be returned instead of a raw ctypes " +"array." msgstr "" -"Identique à :func:`RawArray` à l'exception que suivant la valeur de *lock* un *wrapper* de synchronisation " -"*process-safe* pourra être renvoyé à la place d'un tableau *ctypes* brut." +"Identique à :func:`RawArray` à l'exception que suivant la valeur de *lock* " +"un *wrapper* de synchronisation *process-safe* pourra être renvoyé à la " +"place d'un tableau *ctypes* brut." #: library/multiprocessing.rst:1515 library/multiprocessing.rst:1531 msgid "" -"If *lock* is ``True`` (the default) then a new lock object is created to synchronize access to the value. If " -"*lock* is a :class:`~multiprocessing.Lock` or :class:`~multiprocessing.RLock` object then that will be used to " -"synchronize access to the value. If *lock* is ``False`` then access to the returned object will not be " -"automatically protected by a lock, so it will not necessarily be \"process-safe\"." +"If *lock* is ``True`` (the default) then a new lock object is created to " +"synchronize access to the value. If *lock* is a :class:`~multiprocessing." +"Lock` or :class:`~multiprocessing.RLock` object then that will be used to " +"synchronize access to the value. If *lock* is ``False`` then access to the " +"returned object will not be automatically protected by a lock, so it will " +"not necessarily be \"process-safe\"." msgstr "" -"Si *lock* vaut ``True`` (par défaut), alors un nouveau verrou est créé pour synchroniser l'accès à la valeur. Si " -"*lock* est un objet :class:`~multiprocessing.Lock` ou :class:`~multiprocessing.RLock` alors il sera utilisé pour " -"synchroniser l'accès à la valeur. Si *lock* vaut ``False``, l'accès à l'objet renvoyé ne sera pas automatiquement " -"protégé par un verrou, donc il ne sera pas forcément « *process-safe* »." +"Si *lock* vaut ``True`` (par défaut), alors un nouveau verrou est créé pour " +"synchroniser l'accès à la valeur. Si *lock* est un objet :class:" +"`~multiprocessing.Lock` ou :class:`~multiprocessing.RLock` alors il sera " +"utilisé pour synchroniser l'accès à la valeur. Si *lock* vaut ``False``, " +"l'accès à l'objet renvoyé ne sera pas automatiquement protégé par un verrou, " +"donc il ne sera pas forcément « *process-safe* »." #: library/multiprocessing.rst:1527 msgid "" -"The same as :func:`RawValue` except that depending on the value of *lock* a process-safe synchronization wrapper " -"may be returned instead of a raw ctypes object." +"The same as :func:`RawValue` except that depending on the value of *lock* a " +"process-safe synchronization wrapper may be returned instead of a raw ctypes " +"object." msgstr "" -"Identique à :func:`RawValue` à l'exception que suivant la valeur de *lock* un *wrapper* de synchronisation " -"*process-safe* pourra être renvoyé à la place d'un objet *ctypes* brut." +"Identique à :func:`RawValue` à l'exception que suivant la valeur de *lock* " +"un *wrapper* de synchronisation *process-safe* pourra être renvoyé à la " +"place d'un objet *ctypes* brut." #: library/multiprocessing.rst:1542 -msgid "Return a ctypes object allocated from shared memory which is a copy of the ctypes object *obj*." -msgstr "Renvoie un objet *ctypes* alloué depuis la mémoire partagée, qui est une copie de l'objet *ctypes* *obj*." +msgid "" +"Return a ctypes object allocated from shared memory which is a copy of the " +"ctypes object *obj*." +msgstr "" +"Renvoie un objet *ctypes* alloué depuis la mémoire partagée, qui est une " +"copie de l'objet *ctypes* *obj*." #: library/multiprocessing.rst:1547 msgid "" -"Return a process-safe wrapper object for a ctypes object which uses *lock* to synchronize access. If *lock* is " -"``None`` (the default) then a :class:`multiprocessing.RLock` object is created automatically." +"Return a process-safe wrapper object for a ctypes object which uses *lock* " +"to synchronize access. If *lock* is ``None`` (the default) then a :class:" +"`multiprocessing.RLock` object is created automatically." msgstr "" -"Renvoie un *wrapper* *process-safe* autour de l'objet *ctypes* qui utilise *lock* pour synchroniser l'accès. Si " -"*lock* est ``None`` (par défaut), un objet :class:`multiprocessing.RLock` est créé automatiquement." +"Renvoie un *wrapper* *process-safe* autour de l'objet *ctypes* qui utilise " +"*lock* pour synchroniser l'accès. Si *lock* est ``None`` (par défaut), un " +"objet :class:`multiprocessing.RLock` est créé automatiquement." #: library/multiprocessing.rst:1551 msgid "" -"A synchronized wrapper will have two methods in addition to those of the object it wraps: :meth:`get_obj` returns " -"the wrapped object and :meth:`get_lock` returns the lock object used for synchronization." +"A synchronized wrapper will have two methods in addition to those of the " +"object it wraps: :meth:`get_obj` returns the wrapped object and :meth:" +"`get_lock` returns the lock object used for synchronization." msgstr "" -"Un *wrapper* synchronisé aura deux méthodes en plus de celles de l'objet qu'il enveloppe : :meth:`get_obj` " -"renvoie l'objet *wrappé* et :meth:`get_lock` renvoie le verrou utilisé pour la synchronisation." +"Un *wrapper* synchronisé aura deux méthodes en plus de celles de l'objet " +"qu'il enveloppe : :meth:`get_obj` renvoie l'objet *wrappé* et :meth:" +"`get_lock` renvoie le verrou utilisé pour la synchronisation." #: library/multiprocessing.rst:1555 msgid "" -"Note that accessing the ctypes object through the wrapper can be a lot slower than accessing the raw ctypes " -"object." +"Note that accessing the ctypes object through the wrapper can be a lot " +"slower than accessing the raw ctypes object." msgstr "" -"Notez qu'accéder à l'objet *ctypes* à travers le *wrapper* peut s'avérer beaucoup plus lent qu'accéder " -"directement à l'objet *ctypes* brut." +"Notez qu'accéder à l'objet *ctypes* à travers le *wrapper* peut s'avérer " +"beaucoup plus lent qu'accéder directement à l'objet *ctypes* brut." #: library/multiprocessing.rst:1558 msgid "Synchronized objects support the :term:`context manager` protocol." -msgstr "Les objets synchronisés supportent le protocole :term:`context manager`." +msgstr "" +"Les objets synchronisés supportent le protocole :term:`context manager`." #: library/multiprocessing.rst:1562 msgid "" -"The table below compares the syntax for creating shared ctypes objects from shared memory with the normal ctypes " -"syntax. (In the table ``MyStruct`` is some subclass of :class:`ctypes.Structure`.)" +"The table below compares the syntax for creating shared ctypes objects from " +"shared memory with the normal ctypes syntax. (In the table ``MyStruct`` is " +"some subclass of :class:`ctypes.Structure`.)" msgstr "" -"Le tableau ci-dessous compare la syntaxe de création des objets *ctypes* partagés depuis une mémoire partagée " -"avec la syntaxe normale *ctypes*. (Dans le tableau, ``MyStruct`` est une sous-classe quelconque de :class:`ctypes." +"Le tableau ci-dessous compare la syntaxe de création des objets *ctypes* " +"partagés depuis une mémoire partagée avec la syntaxe normale *ctypes*. (Dans " +"le tableau, ``MyStruct`` est une sous-classe quelconque de :class:`ctypes." "Structure`.)" #: library/multiprocessing.rst:1567 @@ -2053,8 +2497,12 @@ msgid "RawArray('i', (9, 2, 8))" msgstr "RawArray('i', (9, 2, 8))" #: library/multiprocessing.rst:1576 -msgid "Below is an example where a number of ctypes objects are modified by a child process::" -msgstr "Ci-dessous un exemple où des objets *ctypes* sont modifiés par un processus fils ::" +msgid "" +"Below is an example where a number of ctypes objects are modified by a child " +"process::" +msgstr "" +"Ci-dessous un exemple où des objets *ctypes* sont modifiés par un processus " +"fils ::" #: library/multiprocessing.rst:1614 msgid "The results printed are ::" @@ -2066,33 +2514,41 @@ msgstr "Gestionnaires" #: library/multiprocessing.rst:1629 msgid "" -"Managers provide a way to create data which can be shared between different processes, including sharing over a " -"network between processes running on different machines. A manager object controls a server process which manages " -"*shared objects*. Other processes can access the shared objects by using proxies." +"Managers provide a way to create data which can be shared between different " +"processes, including sharing over a network between processes running on " +"different machines. A manager object controls a server process which manages " +"*shared objects*. Other processes can access the shared objects by using " +"proxies." msgstr "" -"Les gestionnaires fournissent un moyen de créer des données qui peuvent être partagées entre les différents " -"processus, incluant le partage à travers le réseau entre des processus tournant sur des machines différentes. Un " -"objet gestionnaire contrôle un processus serveur qui gère les *shared objects*. Les autres processus peuvent " -"accéder aux objets partagés à l'aide de mandataires." +"Les gestionnaires fournissent un moyen de créer des données qui peuvent être " +"partagées entre les différents processus, incluant le partage à travers le " +"réseau entre des processus tournant sur des machines différentes. Un objet " +"gestionnaire contrôle un processus serveur qui gère les *shared objects*. " +"Les autres processus peuvent accéder aux objets partagés à l'aide de " +"mandataires." #: library/multiprocessing.rst:1637 msgid "" -"Returns a started :class:`~multiprocessing.managers.SyncManager` object which can be used for sharing objects " -"between processes. The returned manager object corresponds to a spawned child process and has methods which will " -"create shared objects and return corresponding proxies." +"Returns a started :class:`~multiprocessing.managers.SyncManager` object " +"which can be used for sharing objects between processes. The returned " +"manager object corresponds to a spawned child process and has methods which " +"will create shared objects and return corresponding proxies." msgstr "" -"Renvoie un objet :class:`~multiprocessing.managers.SyncManager` démarré qui peut être utilisé pour partager des " -"objets entre les processus. L'objet gestionnaire renvoyé correspond à un processus enfant instancié et possède " -"des méthodes pour créer des objets partagés et renvoyer les mandataires correspondants." +"Renvoie un objet :class:`~multiprocessing.managers.SyncManager` démarré qui " +"peut être utilisé pour partager des objets entre les processus. L'objet " +"gestionnaire renvoyé correspond à un processus enfant instancié et possède " +"des méthodes pour créer des objets partagés et renvoyer les mandataires " +"correspondants." #: library/multiprocessing.rst:1645 msgid "" -"Manager processes will be shutdown as soon as they are garbage collected or their parent process exits. The " -"manager classes are defined in the :mod:`multiprocessing.managers` module:" +"Manager processes will be shutdown as soon as they are garbage collected or " +"their parent process exits. The manager classes are defined in the :mod:" +"`multiprocessing.managers` module:" msgstr "" -"Les processus gestionnaires seront arrêtés dès qu'ils seront collectés par le ramasse-miettes ou que leur " -"processus parent se terminera. Les classes gestionnaires sont définies dans le module :mod:`multiprocessing." -"managers` :" +"Les processus gestionnaires seront arrêtés dès qu'ils seront collectés par " +"le ramasse-miettes ou que leur processus parent se terminera. Les classes " +"gestionnaires sont définies dans le module :mod:`multiprocessing.managers` :" #: library/multiprocessing.rst:1651 msgid "Create a BaseManager object." @@ -2100,45 +2556,53 @@ msgstr "Crée un objet *BaseManager*." #: library/multiprocessing.rst:1653 msgid "" -"Once created one should call :meth:`start` or ``get_server().serve_forever()`` to ensure that the manager object " -"refers to a started manager process." +"Once created one should call :meth:`start` or ``get_server()." +"serve_forever()`` to ensure that the manager object refers to a started " +"manager process." msgstr "" -"Une fois créé il faut appeler :meth:`start` ou ``get_server().serve_forever()`` pour assurer que l'objet " -"gestionnaire référence un processus gestionnaire démarré." +"Une fois créé il faut appeler :meth:`start` ou ``get_server()." +"serve_forever()`` pour assurer que l'objet gestionnaire référence un " +"processus gestionnaire démarré." #: library/multiprocessing.rst:1656 msgid "" -"*address* is the address on which the manager process listens for new connections. If *address* is ``None`` then " -"an arbitrary one is chosen." +"*address* is the address on which the manager process listens for new " +"connections. If *address* is ``None`` then an arbitrary one is chosen." msgstr "" -"*address* est l'adresse sur laquelle le processus gestionnaire écoute pour de nouvelles connexions. Si *address* " -"est ``None``, une adresse arbitraire est choisie." +"*address* est l'adresse sur laquelle le processus gestionnaire écoute pour " +"de nouvelles connexions. Si *address* est ``None``, une adresse arbitraire " +"est choisie." #: library/multiprocessing.rst:1659 msgid "" -"*authkey* is the authentication key which will be used to check the validity of incoming connections to the " -"server process. If *authkey* is ``None`` then ``current_process().authkey`` is used. Otherwise *authkey* is used " -"and it must be a byte string." +"*authkey* is the authentication key which will be used to check the validity " +"of incoming connections to the server process. If *authkey* is ``None`` " +"then ``current_process().authkey`` is used. Otherwise *authkey* is used and " +"it must be a byte string." msgstr "" -"*authkey* est la clé d'authentification qui sera utilisée pour vérifier la validité des connexions entrantes sur " -"le processus serveur. Si *authkey* est ``None`` alors ``current_process().authkey`` est utilisée. Autrement " +"*authkey* est la clé d'authentification qui sera utilisée pour vérifier la " +"validité des connexions entrantes sur le processus serveur. Si *authkey* est " +"``None`` alors ``current_process().authkey`` est utilisée. Autrement " "*authkey* est utilisée et doit être une chaîne d'octets." #: library/multiprocessing.rst:1666 msgid "" -"Start a subprocess to start the manager. If *initializer* is not ``None`` then the subprocess will call " -"``initializer(*initargs)`` when it starts." +"Start a subprocess to start the manager. If *initializer* is not ``None`` " +"then the subprocess will call ``initializer(*initargs)`` when it starts." msgstr "" -"Démarre un sous-processus pour démarrer le gestionnaire. Si *initializer* n'est pas ``None`` alors le sous-" -"processus appellera ``initializer(*initargs)`` quand il démarrera." +"Démarre un sous-processus pour démarrer le gestionnaire. Si *initializer* " +"n'est pas ``None`` alors le sous-processus appellera " +"``initializer(*initargs)`` quand il démarrera." #: library/multiprocessing.rst:1671 msgid "" -"Returns a :class:`Server` object which represents the actual server under the control of the Manager. The :class:" -"`Server` object supports the :meth:`serve_forever` method::" +"Returns a :class:`Server` object which represents the actual server under " +"the control of the Manager. The :class:`Server` object supports the :meth:" +"`serve_forever` method::" msgstr "" -"Renvoie un objet :class:`Server` qui représente le serveur sous le contrôle du gestionnaire. L'objet :class:" -"`Server` supporte la méthode :meth:`serve_forever` ::" +"Renvoie un objet :class:`Server` qui représente le serveur sous le contrôle " +"du gestionnaire. L'objet :class:`Server` supporte la méthode :meth:" +"`serve_forever` ::" #: library/multiprocessing.rst:1680 msgid ":class:`Server` additionally has an :attr:`address` attribute." @@ -2146,91 +2610,113 @@ msgstr ":class:`Server` possède en plus un attribut :attr:`address`." #: library/multiprocessing.rst:1684 msgid "Connect a local manager object to a remote manager process::" -msgstr "Connecte un objet gestionnaire local au processus gestionnaire distant ::" +msgstr "" +"Connecte un objet gestionnaire local au processus gestionnaire distant ::" #: library/multiprocessing.rst:1692 msgid "" -"Stop the process used by the manager. This is only available if :meth:`start` has been used to start the server " -"process." +"Stop the process used by the manager. This is only available if :meth:" +"`start` has been used to start the server process." msgstr "" -"Stoppe le processus utilisé par le gestionnaire. Cela est disponible uniquement si :meth:`start` a été utilisée " -"pour démarrer le processus serveur." +"Stoppe le processus utilisé par le gestionnaire. Cela est disponible " +"uniquement si :meth:`start` a été utilisée pour démarrer le processus " +"serveur." #: library/multiprocessing.rst:1695 msgid "This can be called multiple times." msgstr "Cette méthode peut être appelée plusieurs fois." #: library/multiprocessing.rst:1699 -msgid "A classmethod which can be used for registering a type or callable with the manager class." +msgid "" +"A classmethod which can be used for registering a type or callable with the " +"manager class." msgstr "" -"Une méthode de classe qui peut être utilisée pour enregistrer un type ou un appelable avec la classe gestionnaire." +"Une méthode de classe qui peut être utilisée pour enregistrer un type ou un " +"appelable avec la classe gestionnaire." #: library/multiprocessing.rst:1702 msgid "" -"*typeid* is a \"type identifier\" which is used to identify a particular type of shared object. This must be a " -"string." +"*typeid* is a \"type identifier\" which is used to identify a particular " +"type of shared object. This must be a string." msgstr "" -"*typeif* est un « *type identifier* » qui est utilisé pour identifier un type particulier d'objet partagé. Cela " -"doit être une chaîne de caractères." +"*typeif* est un « *type identifier* » qui est utilisé pour identifier un " +"type particulier d'objet partagé. Cela doit être une chaîne de caractères." #: library/multiprocessing.rst:1705 msgid "" -"*callable* is a callable used for creating objects for this type identifier. If a manager instance will be " -"connected to the server using the :meth:`connect` method, or if the *create_method* argument is ``False`` then " -"this can be left as ``None``." +"*callable* is a callable used for creating objects for this type " +"identifier. If a manager instance will be connected to the server using " +"the :meth:`connect` method, or if the *create_method* argument is ``False`` " +"then this can be left as ``None``." msgstr "" -"*callable* est un objet appelable utilisé pour créer les objets avec cet identifiant de type. Si une instance de " -"gestionnaire prévoit de se connecter au serveur en utilisant sa méthode :meth:`connect` ou si l'argument " -"*create_method* vaut ``False`` alors cet argument peut être laissé à ``None``." +"*callable* est un objet appelable utilisé pour créer les objets avec cet " +"identifiant de type. Si une instance de gestionnaire prévoit de se connecter " +"au serveur en utilisant sa méthode :meth:`connect` ou si l'argument " +"*create_method* vaut ``False`` alors cet argument peut être laissé à " +"``None``." #: library/multiprocessing.rst:1711 msgid "" -"*proxytype* is a subclass of :class:`BaseProxy` which is used to create proxies for shared objects with this " -"*typeid*. If ``None`` then a proxy class is created automatically." +"*proxytype* is a subclass of :class:`BaseProxy` which is used to create " +"proxies for shared objects with this *typeid*. If ``None`` then a proxy " +"class is created automatically." msgstr "" -"*proxytype* est une sous-classe de :class:`BaseProxy` utilisée pour créer des mandataires autour des objets " -"partagés avec ce *typeid*. S'il est ``None``, une classe mandataire sera créée automatiquement." +"*proxytype* est une sous-classe de :class:`BaseProxy` utilisée pour créer " +"des mandataires autour des objets partagés avec ce *typeid*. S'il est " +"``None``, une classe mandataire sera créée automatiquement." #: library/multiprocessing.rst:1715 msgid "" -"*exposed* is used to specify a sequence of method names which proxies for this typeid should be allowed to access " -"using :meth:`BaseProxy._callmethod`. (If *exposed* is ``None`` then :attr:`proxytype._exposed_` is used instead " -"if it exists.) In the case where no exposed list is specified, all \"public methods\" of the shared object will " -"be accessible. (Here a \"public method\" means any attribute which has a :meth:`~object.__call__` method and " -"whose name does not begin with ``'_'``.)" -msgstr "" -"*exposed* est utilisé pour préciser une séquence de noms de méthodes dont les mandataires pour ce *typeid* " -"doivent être autorisés à accéder via :meth:`BaseProxy._callmethod`. (Si *exposed* est ``None`` alors :attr:" -"`proxytype._exposed_` est utilisé à la place s'il existe.) Dans le cas où aucune liste *exposed* n'est précisée, " -"toutes les « méthodes publiques » de l'objet partagé seront accessibles. (Ici une « méthode publique » signifie " -"n'importe quel attribut qui possède une méthode :meth:`~object.__call__` et dont le nom ne commence pas par un " -"``'_'``.)" +"*exposed* is used to specify a sequence of method names which proxies for " +"this typeid should be allowed to access using :meth:`BaseProxy." +"_callmethod`. (If *exposed* is ``None`` then :attr:`proxytype._exposed_` is " +"used instead if it exists.) In the case where no exposed list is specified, " +"all \"public methods\" of the shared object will be accessible. (Here a " +"\"public method\" means any attribute which has a :meth:`~object.__call__` " +"method and whose name does not begin with ``'_'``.)" +msgstr "" +"*exposed* est utilisé pour préciser une séquence de noms de méthodes dont " +"les mandataires pour ce *typeid* doivent être autorisés à accéder via :meth:" +"`BaseProxy._callmethod`. (Si *exposed* est ``None`` alors :attr:`proxytype." +"_exposed_` est utilisé à la place s'il existe.) Dans le cas où aucune liste " +"*exposed* n'est précisée, toutes les « méthodes publiques » de l'objet " +"partagé seront accessibles. (Ici une « méthode publique » signifie n'importe " +"quel attribut qui possède une méthode :meth:`~object.__call__` et dont le " +"nom ne commence pas par un ``'_'``.)" #: library/multiprocessing.rst:1724 msgid "" -"*method_to_typeid* is a mapping used to specify the return type of those exposed methods which should return a " -"proxy. It maps method names to typeid strings. (If *method_to_typeid* is ``None`` then :attr:`proxytype." -"_method_to_typeid_` is used instead if it exists.) If a method's name is not a key of this mapping or if the " -"mapping is ``None`` then the object returned by the method will be copied by value." -msgstr "" -"*method_to_typeid* est un tableau associatif utilisé pour préciser le type de retour de ces méthodes exposées qui " -"doivent renvoyer un mandataire. Il associé un nom de méthode à une chaîne de caractères *typeid*. (Si " -"*method_to_typeid* est ``None``, :attr:`proxytype._method_to_typeid_` est utilisé à la place s'il existe). Si le " -"nom d'une méthode n'est pas une clé de ce tableau associatif ou si la valeur associée est ``None``, l'objet " +"*method_to_typeid* is a mapping used to specify the return type of those " +"exposed methods which should return a proxy. It maps method names to typeid " +"strings. (If *method_to_typeid* is ``None`` then :attr:`proxytype." +"_method_to_typeid_` is used instead if it exists.) If a method's name is " +"not a key of this mapping or if the mapping is ``None`` then the object " +"returned by the method will be copied by value." +msgstr "" +"*method_to_typeid* est un tableau associatif utilisé pour préciser le type " +"de retour de ces méthodes exposées qui doivent renvoyer un mandataire. Il " +"associé un nom de méthode à une chaîne de caractères *typeid*. (Si " +"*method_to_typeid* est ``None``, :attr:`proxytype._method_to_typeid_` est " +"utilisé à la place s'il existe). Si le nom d'une méthode n'est pas une clé " +"de ce tableau associatif ou si la valeur associée est ``None``, l'objet " "renvoyé par la méthode sera une copie de la valeur." #: library/multiprocessing.rst:1731 msgid "" -"*create_method* determines whether a method should be created with name *typeid* which can be used to tell the " -"server process to create a new shared object and return a proxy for it. By default it is ``True``." +"*create_method* determines whether a method should be created with name " +"*typeid* which can be used to tell the server process to create a new shared " +"object and return a proxy for it. By default it is ``True``." msgstr "" -"*create_method* détermine si une méthode devrait être créée avec le nom *typeid*, qui peut être utilisée pour " -"indiquer au processus serveur de créer un nouvel objet partagé et d'en renvoyer un mandataire. a valeur par " -"défaut est ``True``." +"*create_method* détermine si une méthode devrait être créée avec le nom " +"*typeid*, qui peut être utilisée pour indiquer au processus serveur de créer " +"un nouvel objet partagé et d'en renvoyer un mandataire. a valeur par défaut " +"est ``True``." #: library/multiprocessing.rst:1735 msgid ":class:`BaseManager` instances also have one read-only property:" -msgstr "Les instances de :class:`BaseManager` ont aussi une propriété en lecture seule :" +msgstr "" +"Les instances de :class:`BaseManager` ont aussi une propriété en lecture " +"seule :" #: library/multiprocessing.rst:1739 msgid "The address used by the manager." @@ -2238,105 +2724,149 @@ msgstr "L'adresse utilisée par le gestionnaire." #: library/multiprocessing.rst:1741 msgid "" -"Manager objects support the context management protocol -- see :ref:`typecontextmanager`. :meth:`~contextmanager." -"__enter__` starts the server process (if it has not already started) and then returns the manager object. :meth:" -"`~contextmanager.__exit__` calls :meth:`shutdown`." +"Manager objects support the context management protocol -- see :ref:" +"`typecontextmanager`. :meth:`~contextmanager.__enter__` starts the server " +"process (if it has not already started) and then returns the manager " +"object. :meth:`~contextmanager.__exit__` calls :meth:`shutdown`." msgstr "" -"Les objets gestionnaires supportent le protocole des gestionnaires de contexte – voir :ref:`typecontextmanager`. :" -"meth:`~contextmanager.__enter__` démarre le processus serveur (s'il n'a pas déjà été démarré) et renvoie l'objet " -"gestionnaire. :meth:`~contextmanager.__exit__` appelle :meth:`shutdown`." +"Les objets gestionnaires supportent le protocole des gestionnaires de " +"contexte – voir :ref:`typecontextmanager`. :meth:`~contextmanager.__enter__` " +"démarre le processus serveur (s'il n'a pas déjà été démarré) et renvoie " +"l'objet gestionnaire. :meth:`~contextmanager.__exit__` appelle :meth:" +"`shutdown`." #: library/multiprocessing.rst:1747 msgid "" -"In previous versions :meth:`~contextmanager.__enter__` did not start the manager's server process if it was not " -"already started." +"In previous versions :meth:`~contextmanager.__enter__` did not start the " +"manager's server process if it was not already started." msgstr "" -"Dans les versions précédentes :meth:`~contextmanager.__enter__` ne démarrait pas le processus serveur du " -"gestionnaire s'il n'était pas déjà démarré." +"Dans les versions précédentes :meth:`~contextmanager.__enter__` ne démarrait " +"pas le processus serveur du gestionnaire s'il n'était pas déjà démarré." #: library/multiprocessing.rst:1752 msgid "" -"A subclass of :class:`BaseManager` which can be used for the synchronization of processes. Objects of this type " -"are returned by :func:`multiprocessing.Manager`." +"A subclass of :class:`BaseManager` which can be used for the synchronization " +"of processes. Objects of this type are returned by :func:`multiprocessing." +"Manager`." msgstr "" -"Une sous-classe de :class:`BaseManager` qui peut être utilisée pour la synchronisation entre processus. Des " -"objets de ce type sont renvoyés par :func:`multiprocessing.Manager`." +"Une sous-classe de :class:`BaseManager` qui peut être utilisée pour la " +"synchronisation entre processus. Des objets de ce type sont renvoyés par :" +"func:`multiprocessing.Manager`." #: library/multiprocessing.rst:1756 msgid "" -"Its methods create and return :ref:`multiprocessing-proxy_objects` for a number of commonly used data types to be " -"synchronized across processes. This notably includes shared lists and dictionaries." +"Its methods create and return :ref:`multiprocessing-proxy_objects` for a " +"number of commonly used data types to be synchronized across processes. This " +"notably includes shared lists and dictionaries." msgstr "" -"Ces méthodes créent et renvoient des :ref:`multiprocessing-proxy_objects` pour un certain nombre de types de " -"données communément utilisés pour être synchronisés entre les processus. Elles incluent notamment des listes et " +"Ces méthodes créent et renvoient des :ref:`multiprocessing-proxy_objects` " +"pour un certain nombre de types de données communément utilisés pour être " +"synchronisés entre les processus. Elles incluent notamment des listes et " "dictionnaires partagés." #: library/multiprocessing.rst:1762 -msgid "Create a shared :class:`threading.Barrier` object and return a proxy for it." -msgstr "Crée un objet :class:`threading.Barrier` partagé et renvoie un mandataire pour cet objet." +msgid "" +"Create a shared :class:`threading.Barrier` object and return a proxy for it." +msgstr "" +"Crée un objet :class:`threading.Barrier` partagé et renvoie un mandataire " +"pour cet objet." #: library/multiprocessing.rst:1769 -msgid "Create a shared :class:`threading.BoundedSemaphore` object and return a proxy for it." -msgstr "Crée un objet :class:`threading.BoundedSemaphore` partagé et renvoie un mandataire pour cet objet." +msgid "" +"Create a shared :class:`threading.BoundedSemaphore` object and return a " +"proxy for it." +msgstr "" +"Crée un objet :class:`threading.BoundedSemaphore` partagé et renvoie un " +"mandataire pour cet objet." #: library/multiprocessing.rst:1774 -msgid "Create a shared :class:`threading.Condition` object and return a proxy for it." -msgstr "Crée un objet :class:`threading.Condition` partagé et renvoie un mandataire pour cet objet." +msgid "" +"Create a shared :class:`threading.Condition` object and return a proxy for " +"it." +msgstr "" +"Crée un objet :class:`threading.Condition` partagé et renvoie un mandataire " +"pour cet objet." #: library/multiprocessing.rst:1777 msgid "" -"If *lock* is supplied then it should be a proxy for a :class:`threading.Lock` or :class:`threading.RLock` object." +"If *lock* is supplied then it should be a proxy for a :class:`threading." +"Lock` or :class:`threading.RLock` object." msgstr "" -"Si *lock* est fourni alors il doit être un mandataire pour un objet :class:`threading.Lock` ou :class:`threading." -"RLock`." +"Si *lock* est fourni alors il doit être un mandataire pour un objet :class:" +"`threading.Lock` ou :class:`threading.RLock`." #: library/multiprocessing.rst:1785 -msgid "Create a shared :class:`threading.Event` object and return a proxy for it." -msgstr "Crée un objet :class:`threading.Event` partagé et renvoie un mandataire pour cet objet." +msgid "" +"Create a shared :class:`threading.Event` object and return a proxy for it." +msgstr "" +"Crée un objet :class:`threading.Event` partagé et renvoie un mandataire pour " +"cet objet." #: library/multiprocessing.rst:1789 -msgid "Create a shared :class:`threading.Lock` object and return a proxy for it." -msgstr "Crée un objet :class:`threading.Lock` partagé et renvoie un mandataire pour cet objet." +msgid "" +"Create a shared :class:`threading.Lock` object and return a proxy for it." +msgstr "" +"Crée un objet :class:`threading.Lock` partagé et renvoie un mandataire pour " +"cet objet." #: library/multiprocessing.rst:1793 msgid "Create a shared :class:`Namespace` object and return a proxy for it." -msgstr "Crée un objet :class:`Namespace` partagé et renvoie un mandataire pour cet objet." +msgstr "" +"Crée un objet :class:`Namespace` partagé et renvoie un mandataire pour cet " +"objet." #: library/multiprocessing.rst:1797 msgid "Create a shared :class:`queue.Queue` object and return a proxy for it." -msgstr "Crée un objet :class:`queue.Queue` partagé et renvoie un mandataire pour cet objet." +msgstr "" +"Crée un objet :class:`queue.Queue` partagé et renvoie un mandataire pour cet " +"objet." #: library/multiprocessing.rst:1801 -msgid "Create a shared :class:`threading.RLock` object and return a proxy for it." -msgstr "Crée un objet :class:`threading.RLock` partagé et renvoie un mandataire pour cet objet." +msgid "" +"Create a shared :class:`threading.RLock` object and return a proxy for it." +msgstr "" +"Crée un objet :class:`threading.RLock` partagé et renvoie un mandataire pour " +"cet objet." #: library/multiprocessing.rst:1805 -msgid "Create a shared :class:`threading.Semaphore` object and return a proxy for it." -msgstr "Crée un objet :class:`threading.Semaphore` partagé et renvoie un mandataire pour cet objet." +msgid "" +"Create a shared :class:`threading.Semaphore` object and return a proxy for " +"it." +msgstr "" +"Crée un objet :class:`threading.Semaphore` partagé et renvoie un mandataire " +"pour cet objet." #: library/multiprocessing.rst:1810 msgid "Create an array and return a proxy for it." msgstr "Crée un tableau et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1814 -msgid "Create an object with a writable ``value`` attribute and return a proxy for it." -msgstr "Crée un objet avec un attribut ``value`` accessible en écriture et renvoie un mandataire pour cet objet." +msgid "" +"Create an object with a writable ``value`` attribute and return a proxy for " +"it." +msgstr "" +"Crée un objet avec un attribut ``value`` accessible en écriture et renvoie " +"un mandataire pour cet objet." #: library/multiprocessing.rst:1821 msgid "Create a shared :class:`dict` object and return a proxy for it." -msgstr "Crée un objet :class:`dict` partagé et renvoie un mandataire pour cet objet." +msgstr "" +"Crée un objet :class:`dict` partagé et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1826 msgid "Create a shared :class:`list` object and return a proxy for it." -msgstr "Crée un objet :class:`list` partagé et renvoie un mandataire pour cet objet." +msgstr "" +"Crée un objet :class:`list` partagé et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1828 msgid "" -"Shared objects are capable of being nested. For example, a shared container object such as a shared list can " -"contain other shared objects which will all be managed and synchronized by the :class:`SyncManager`." +"Shared objects are capable of being nested. For example, a shared container " +"object such as a shared list can contain other shared objects which will all " +"be managed and synchronized by the :class:`SyncManager`." msgstr "" -"Les objets partagés peuvent être imbriqués. Par exemple, un conteneur partagé tel qu'une liste partagée peu " -"contenir d'autres objets partagés qui seront aussi gérés et synchronisés par le :class:`SyncManager`." +"Les objets partagés peuvent être imbriqués. Par exemple, un conteneur " +"partagé tel qu'une liste partagée peu contenir d'autres objets partagés qui " +"seront aussi gérés et synchronisés par le :class:`SyncManager`." #: library/multiprocessing.rst:1835 msgid "A type that can register with :class:`SyncManager`." @@ -2344,19 +2874,21 @@ msgstr "Un type qui peut être enregistré avec :class:`SyncManager`." #: library/multiprocessing.rst:1837 msgid "" -"A namespace object has no public methods, but does have writable attributes. Its representation shows the values " -"of its attributes." +"A namespace object has no public methods, but does have writable attributes. " +"Its representation shows the values of its attributes." msgstr "" -"Un espace de nommage n'a pas de méthodes publiques, mais possède des attributs accessibles en écriture. Sa " -"représentation montre les valeurs de ses attributs." +"Un espace de nommage n'a pas de méthodes publiques, mais possède des " +"attributs accessibles en écriture. Sa représentation montre les valeurs de " +"ses attributs." #: library/multiprocessing.rst:1840 msgid "" -"However, when using a proxy for a namespace object, an attribute beginning with ``'_'`` will be an attribute of " -"the proxy and not an attribute of the referent:" +"However, when using a proxy for a namespace object, an attribute beginning " +"with ``'_'`` will be an attribute of the proxy and not an attribute of the " +"referent:" msgstr "" -"Cependant, en utilisant un mandataire pour un espace de nommage, un attribut débutant par ``'_'`` est un attribut " -"du mandataire et non de l'objet cible :" +"Cependant, en utilisant un mandataire pour un espace de nommage, un attribut " +"débutant par ``'_'`` est un attribut du mandataire et non de l'objet cible :" #: library/multiprocessing.rst:1856 msgid "Customized managers" @@ -2364,11 +2896,13 @@ msgstr "Gestionnaires personnalisés" #: library/multiprocessing.rst:1858 msgid "" -"To create one's own manager, one creates a subclass of :class:`BaseManager` and uses the :meth:`~BaseManager." -"register` classmethod to register new types or callables with the manager class. For example::" +"To create one's own manager, one creates a subclass of :class:`BaseManager` " +"and uses the :meth:`~BaseManager.register` classmethod to register new types " +"or callables with the manager class. For example::" msgstr "" -"Pour créer son propre gestionnaire, il faut créer une sous-classe de :class:`BaseManager` et utiliser la méthode " -"de classe :meth:`~BaseManager.register` pour enregistrer de nouveaux types ou *callables* au gestionnaire. Par " +"Pour créer son propre gestionnaire, il faut créer une sous-classe de :class:" +"`BaseManager` et utiliser la méthode de classe :meth:`~BaseManager.register` " +"pour enregistrer de nouveaux types ou *callables* au gestionnaire. Par " "exemple ::" #: library/multiprocessing.rst:1883 @@ -2377,17 +2911,20 @@ msgstr "Utiliser un gestionnaire distant" #: library/multiprocessing.rst:1885 msgid "" -"It is possible to run a manager server on one machine and have clients use it from other machines (assuming that " -"the firewalls involved allow it)." +"It is possible to run a manager server on one machine and have clients use " +"it from other machines (assuming that the firewalls involved allow it)." msgstr "" -"Il est possible de lancer un serveur gestionnaire sur une machine et d'avoir des clients l'utilisant sur d'autres " -"machines (en supposant que les pare-feus impliqués l'autorisent)." +"Il est possible de lancer un serveur gestionnaire sur une machine et d'avoir " +"des clients l'utilisant sur d'autres machines (en supposant que les pare-" +"feus impliqués l'autorisent)." #: library/multiprocessing.rst:1888 -msgid "Running the following commands creates a server for a single shared queue which remote clients can access::" +msgid "" +"Running the following commands creates a server for a single shared queue " +"which remote clients can access::" msgstr "" -"Exécuter les commandes suivantes crée un serveur pour une file simple partagée à laquelle des clients distants " -"peuvent accéder ::" +"Exécuter les commandes suivantes crée un serveur pour une file simple " +"partagée à laquelle des clients distants peuvent accéder ::" #: library/multiprocessing.rst:1900 msgid "One client can access the server as follows::" @@ -2398,10 +2935,12 @@ msgid "Another client can also use it::" msgstr "Un autre client peut aussi l'utiliser ::" #: library/multiprocessing.rst:1921 -msgid "Local processes can also access that queue, using the code from above on the client to access it remotely::" +msgid "" +"Local processes can also access that queue, using the code from above on the " +"client to access it remotely::" msgstr "" -"Les processus locaux peuvent aussi accéder à cette file, utilisant le code précédent sur le client pour y " -"accéder à distance ::" +"Les processus locaux peuvent aussi accéder à cette file, utilisant le code " +"précédent sur le client pour y accéder à distance ::" #: library/multiprocessing.rst:1946 msgid "Proxy Objects" @@ -2409,89 +2948,117 @@ msgstr "Objets mandataires" #: library/multiprocessing.rst:1948 msgid "" -"A proxy is an object which *refers* to a shared object which lives (presumably) in a different process. The " -"shared object is said to be the *referent* of the proxy. Multiple proxy objects may have the same referent." +"A proxy is an object which *refers* to a shared object which lives " +"(presumably) in a different process. The shared object is said to be the " +"*referent* of the proxy. Multiple proxy objects may have the same referent." msgstr "" -"Un mandataire est un objet qui *référence* un objet partagé appartenant (supposément) à un processus différent. " -"L'objet partagé est appelé le *référent* du mandataire. Plusieurs mandataires peuvent avoir un même référent." +"Un mandataire est un objet qui *référence* un objet partagé appartenant " +"(supposément) à un processus différent. L'objet partagé est appelé le " +"*référent* du mandataire. Plusieurs mandataires peuvent avoir un même " +"référent." #: library/multiprocessing.rst:1952 msgid "" -"A proxy object has methods which invoke corresponding methods of its referent (although not every method of the " -"referent will necessarily be available through the proxy). In this way, a proxy can be used just like its " -"referent can:" +"A proxy object has methods which invoke corresponding methods of its " +"referent (although not every method of the referent will necessarily be " +"available through the proxy). In this way, a proxy can be used just like " +"its referent can:" msgstr "" -"Un mandataire possède des méthodes qui appellent les méthodes correspondantes du référent (bien que toutes les " -"méthodes du référent ne soient pas nécessairement accessibles à travers le mandataire). De cette manière, un " -"mandataire peut être utilisé comme le serait sont référent :" +"Un mandataire possède des méthodes qui appellent les méthodes " +"correspondantes du référent (bien que toutes les méthodes du référent ne " +"soient pas nécessairement accessibles à travers le mandataire). De cette " +"manière, un mandataire peut être utilisé comme le serait sont référent :" #: library/multiprocessing.rst:1970 msgid "" -"Notice that applying :func:`str` to a proxy will return the representation of the referent, whereas applying :" -"func:`repr` will return the representation of the proxy." +"Notice that applying :func:`str` to a proxy will return the representation " +"of the referent, whereas applying :func:`repr` will return the " +"representation of the proxy." msgstr "" -"Notez qu'appliquer :func:`str` à un mandataire renvoie la représentation du référent, alors que :func:`repr` " -"renvoie celle du mandataire." +"Notez qu'appliquer :func:`str` à un mandataire renvoie la représentation du " +"référent, alors que :func:`repr` renvoie celle du mandataire." #: library/multiprocessing.rst:1974 msgid "" -"An important feature of proxy objects is that they are picklable so they can be passed between processes. As " -"such, a referent can contain :ref:`multiprocessing-proxy_objects`. This permits nesting of these managed lists, " -"dicts, and other :ref:`multiprocessing-proxy_objects`:" +"An important feature of proxy objects is that they are picklable so they can " +"be passed between processes. As such, a referent can contain :ref:" +"`multiprocessing-proxy_objects`. This permits nesting of these managed " +"lists, dicts, and other :ref:`multiprocessing-proxy_objects`:" msgstr "" -"Une fonctionnalité importantes des objets mandataires est qu'ils sont sérialisables et peuvent donc être échangés " -"entre les processus. Ainsi, un référent peut contenir des :ref:`multiprocessing-proxy_objects`. Cela permet " -"d'imbriquer des listes et dictionnaires gérés ainsi que d'autres :ref:`multiprocessing-proxy_objects` :" +"Une fonctionnalité importantes des objets mandataires est qu'ils sont " +"sérialisables et peuvent donc être échangés entre les processus. Ainsi, un " +"référent peut contenir des :ref:`multiprocessing-proxy_objects`. Cela permet " +"d'imbriquer des listes et dictionnaires gérés ainsi que d'autres :ref:" +"`multiprocessing-proxy_objects` :" #: library/multiprocessing.rst:1990 msgid "Similarly, dict and list proxies may be nested inside one another::" -msgstr "De même, les mandataires de listes et dictionnaires peuvent être imbriqués dans d'autres ::" +msgstr "" +"De même, les mandataires de listes et dictionnaires peuvent être imbriqués " +"dans d'autres ::" #: library/multiprocessing.rst:2003 msgid "" -"If standard (non-proxy) :class:`list` or :class:`dict` objects are contained in a referent, modifications to " -"those mutable values will not be propagated through the manager because the proxy has no way of knowing when the " -"values contained within are modified. However, storing a value in a container proxy (which triggers a " -"``__setitem__`` on the proxy object) does propagate through the manager and so to effectively modify such an " -"item, one could re-assign the modified value to the container proxy::" -msgstr "" -"Si des objets standards (non *proxyfiés*) :class:`list` ou :class:`dict` sont contenus dans un référent, les " -"modifications sur ces valeurs mutables ne seront pas propagées à travers le gestionnaire parce que le mandataire " -"n'a aucun moyen de savoir quand les valeurs contenues sont modifiées. Cependant, stocker une valeur dans un " -"conteneur mandataire (qui déclenche un appel à ``__setitem__`` sur le mandataire) propage bien la modification à " -"travers le gestionnaire et modifie effectivement l'élément, il est ainsi possible de réassigner la valeur " -"modifiée au conteneur mandataire ::" +"If standard (non-proxy) :class:`list` or :class:`dict` objects are contained " +"in a referent, modifications to those mutable values will not be propagated " +"through the manager because the proxy has no way of knowing when the values " +"contained within are modified. However, storing a value in a container " +"proxy (which triggers a ``__setitem__`` on the proxy object) does propagate " +"through the manager and so to effectively modify such an item, one could re-" +"assign the modified value to the container proxy::" +msgstr "" +"Si des objets standards (non *proxyfiés*) :class:`list` ou :class:`dict` " +"sont contenus dans un référent, les modifications sur ces valeurs mutables " +"ne seront pas propagées à travers le gestionnaire parce que le mandataire " +"n'a aucun moyen de savoir quand les valeurs contenues sont modifiées. " +"Cependant, stocker une valeur dans un conteneur mandataire (qui déclenche un " +"appel à ``__setitem__`` sur le mandataire) propage bien la modification à " +"travers le gestionnaire et modifie effectivement l'élément, il est ainsi " +"possible de réassigner la valeur modifiée au conteneur mandataire ::" #: library/multiprocessing.rst:2022 msgid "" -"This approach is perhaps less convenient than employing nested :ref:`multiprocessing-proxy_objects` for most use " -"cases but also demonstrates a level of control over the synchronization." +"This approach is perhaps less convenient than employing nested :ref:" +"`multiprocessing-proxy_objects` for most use cases but also demonstrates a " +"level of control over the synchronization." msgstr "" -"Cette approche est peut-être moins pratique que d'utiliser des :ref:`multiprocessing-proxy_objects` imbriqués " -"pour la majorité des cas d'utilisation, mais démontre aussi un certain niveau de contrôle sur la synchronisation." +"Cette approche est peut-être moins pratique que d'utiliser des :ref:" +"`multiprocessing-proxy_objects` imbriqués pour la majorité des cas " +"d'utilisation, mais démontre aussi un certain niveau de contrôle sur la " +"synchronisation." #: library/multiprocessing.rst:2028 msgid "" -"The proxy types in :mod:`multiprocessing` do nothing to support comparisons by value. So, for instance, we have:" +"The proxy types in :mod:`multiprocessing` do nothing to support comparisons " +"by value. So, for instance, we have:" msgstr "" -"Les types de mandataires de :mod:`multiprocessing` n'implémentent rien pour la comparaison par valeurs. Par " -"exemple, on a :" +"Les types de mandataires de :mod:`multiprocessing` n'implémentent rien pour " +"la comparaison par valeurs. Par exemple, on a :" #: library/multiprocessing.rst:2036 -msgid "One should just use a copy of the referent instead when making comparisons." -msgstr "Il faut à la place simplement utiliser une copie du référent pour faire les comparaisons." +msgid "" +"One should just use a copy of the referent instead when making comparisons." +msgstr "" +"Il faut à la place simplement utiliser une copie du référent pour faire les " +"comparaisons." #: library/multiprocessing.rst:2040 msgid "Proxy objects are instances of subclasses of :class:`BaseProxy`." -msgstr "Les objets mandataires sont des instances de sous-classes de :class:`BaseProxy`." +msgstr "" +"Les objets mandataires sont des instances de sous-classes de :class:" +"`BaseProxy`." #: library/multiprocessing.rst:2044 msgid "Call and return the result of a method of the proxy's referent." -msgstr "Appelle et renvoie le résultat d'une méthode du référent du mandataire." +msgstr "" +"Appelle et renvoie le résultat d'une méthode du référent du mandataire." #: library/multiprocessing.rst:2046 -msgid "If ``proxy`` is a proxy whose referent is ``obj`` then the expression ::" -msgstr "Si ``proxy`` est un mandataire sont le référent est ``obj``, alors l'expression ::" +msgid "" +"If ``proxy`` is a proxy whose referent is ``obj`` then the expression ::" +msgstr "" +"Si ``proxy`` est un mandataire sont le référent est ``obj``, alors " +"l'expression ::" #: library/multiprocessing.rst:2050 msgid "will evaluate the expression ::" @@ -2503,25 +3070,33 @@ msgstr "dans le processus du gestionnaire." #: library/multiprocessing.rst:2056 msgid "" -"The returned value will be a copy of the result of the call or a proxy to a new shared object -- see " -"documentation for the *method_to_typeid* argument of :meth:`BaseManager.register`." +"The returned value will be a copy of the result of the call or a proxy to a " +"new shared object -- see documentation for the *method_to_typeid* argument " +"of :meth:`BaseManager.register`." msgstr "" -"La valeur renvoyée sera une copie du résultat de l'appel ou un mandataire sur un nouvel objet partagé – voir l'a " -"documentation de l'argument *method_to_typeid* de :meth:`BaseManager.register`." +"La valeur renvoyée sera une copie du résultat de l'appel ou un mandataire " +"sur un nouvel objet partagé – voir l'a documentation de l'argument " +"*method_to_typeid* de :meth:`BaseManager.register`." #: library/multiprocessing.rst:2060 msgid "" -"If an exception is raised by the call, then is re-raised by :meth:`_callmethod`. If some other exception is " -"raised in the manager's process then this is converted into a :exc:`RemoteError` exception and is raised by :meth:" -"`_callmethod`." +"If an exception is raised by the call, then is re-raised by :meth:" +"`_callmethod`. If some other exception is raised in the manager's process " +"then this is converted into a :exc:`RemoteError` exception and is raised by :" +"meth:`_callmethod`." msgstr "" -"Si une exception est levée par l'appel, elle est relayée par :meth:`_callmethod`. Si une autre exception est " -"levée par le processus du gestionnaire, elle est convertie en une :exc:`RemoteError` et est levée par :meth:" -"`_callmethod`." +"Si une exception est levée par l'appel, elle est relayée par :meth:" +"`_callmethod`. Si une autre exception est levée par le processus du " +"gestionnaire, elle est convertie en une :exc:`RemoteError` et est levée par :" +"meth:`_callmethod`." #: library/multiprocessing.rst:2065 -msgid "Note in particular that an exception will be raised if *methodname* has not been *exposed*." -msgstr "Notez en particulier qu'une exception est levée si *methodname* n'est pas *exposée*." +msgid "" +"Note in particular that an exception will be raised if *methodname* has not " +"been *exposed*." +msgstr "" +"Notez en particulier qu'une exception est levée si *methodname* n'est pas " +"*exposée*." #: library/multiprocessing.rst:2068 msgid "An example of the usage of :meth:`_callmethod`:" @@ -2549,90 +3124,115 @@ msgstr "Nettoyage" #: library/multiprocessing.rst:2100 msgid "" -"A proxy object uses a weakref callback so that when it gets garbage collected it deregisters itself from the " -"manager which owns its referent." +"A proxy object uses a weakref callback so that when it gets garbage " +"collected it deregisters itself from the manager which owns its referent." msgstr "" -"Un mandataire utilise un *callback* sous une référence faible de façon à ce que quand il est collecté par le " -"ramasse-miettes, il se désenregistre auprès du gestionnaire qui possède le référent." +"Un mandataire utilise un *callback* sous une référence faible de façon à ce " +"que quand il est collecté par le ramasse-miettes, il se désenregistre auprès " +"du gestionnaire qui possède le référent." #: library/multiprocessing.rst:2103 -msgid "A shared object gets deleted from the manager process when there are no longer any proxies referring to it." -msgstr "Un objet partagé est supprimé par le processus gestionnaire quand plus aucun mandataire ne le référence." +msgid "" +"A shared object gets deleted from the manager process when there are no " +"longer any proxies referring to it." +msgstr "" +"Un objet partagé est supprimé par le processus gestionnaire quand plus aucun " +"mandataire ne le référence." #: library/multiprocessing.rst:2108 msgid "Process Pools" msgstr "Pools de processus" #: library/multiprocessing.rst:2113 -msgid "One can create a pool of processes which will carry out tasks submitted to it with the :class:`Pool` class." +msgid "" +"One can create a pool of processes which will carry out tasks submitted to " +"it with the :class:`Pool` class." msgstr "" -"On peut créer un pool de processus qui exécuteront les tâches qui lui seront soumises avec la classe :class:" -"`Pool`." +"On peut créer un pool de processus qui exécuteront les tâches qui lui seront " +"soumises avec la classe :class:`Pool`." #: library/multiprocessing.rst:2118 msgid "" -"A process pool object which controls a pool of worker processes to which jobs can be submitted. It supports " -"asynchronous results with timeouts and callbacks and has a parallel map implementation." +"A process pool object which controls a pool of worker processes to which " +"jobs can be submitted. It supports asynchronous results with timeouts and " +"callbacks and has a parallel map implementation." msgstr "" -"Un objet *process pool* qui contrôle un pool de processus *workers* auquel sont soumises des tâches. Il supporte " -"les résultats asynchrones avec des *timeouts* et des *callbacks* et possède une implémentation parallèle de " +"Un objet *process pool* qui contrôle un pool de processus *workers* auquel " +"sont soumises des tâches. Il supporte les résultats asynchrones avec des " +"*timeouts* et des *callbacks* et possède une implémentation parallèle de " "*map*." #: library/multiprocessing.rst:2122 msgid "" -"*processes* is the number of worker processes to use. If *processes* is ``None`` then the number returned by :" -"func:`os.cpu_count` is used." +"*processes* is the number of worker processes to use. If *processes* is " +"``None`` then the number returned by :func:`os.cpu_count` is used." msgstr "" -"*processes* est le nombre de processus *workers* à utiliser. Si *processes* est ``None``, le nombre renvoyé par :" -"func:`os.cpu_count` est utilisé." +"*processes* est le nombre de processus *workers* à utiliser. Si *processes* " +"est ``None``, le nombre renvoyé par :func:`os.cpu_count` est utilisé." #: library/multiprocessing.rst:2125 library/multiprocessing.rst:2684 msgid "" -"If *initializer* is not ``None`` then each worker process will call ``initializer(*initargs)`` when it starts." +"If *initializer* is not ``None`` then each worker process will call " +"``initializer(*initargs)`` when it starts." msgstr "" -"Si *initializer* n'est pas ``None``, chaque processus *worker* appellera ``initializer(*initargs)`` en démarrant." +"Si *initializer* n'est pas ``None``, chaque processus *worker* appellera " +"``initializer(*initargs)`` en démarrant." #: library/multiprocessing.rst:2128 msgid "" -"*maxtasksperchild* is the number of tasks a worker process can complete before it will exit and be replaced with " -"a fresh worker process, to enable unused resources to be freed. The default *maxtasksperchild* is ``None``, which " -"means worker processes will live as long as the pool." +"*maxtasksperchild* is the number of tasks a worker process can complete " +"before it will exit and be replaced with a fresh worker process, to enable " +"unused resources to be freed. The default *maxtasksperchild* is ``None``, " +"which means worker processes will live as long as the pool." msgstr "" -"*maxtasksperchild* est le nombre de tâches qu'un processus *worker* peut accomplir avant de se fermer et d'être " -"remplacé par un *worker* frais, pour permettre aux ressources inutilisées d'être libérées. Par défaut " -"*maxtasksperchild* est ``None``, ce qui signifie que le *worker* vit aussi longtemps que le pool." +"*maxtasksperchild* est le nombre de tâches qu'un processus *worker* peut " +"accomplir avant de se fermer et d'être remplacé par un *worker* frais, pour " +"permettre aux ressources inutilisées d'être libérées. Par défaut " +"*maxtasksperchild* est ``None``, ce qui signifie que le *worker* vit aussi " +"longtemps que le pool." #: library/multiprocessing.rst:2133 msgid "" -"*context* can be used to specify the context used for starting the worker processes. Usually a pool is created " -"using the function :func:`multiprocessing.Pool` or the :meth:`Pool` method of a context object. In both cases " -"*context* is set appropriately." +"*context* can be used to specify the context used for starting the worker " +"processes. Usually a pool is created using the function :func:" +"`multiprocessing.Pool` or the :meth:`Pool` method of a context object. In " +"both cases *context* is set appropriately." msgstr "" -"*context* peut être utilisé pour préciser le contexte utilisé pour démarrer les processus *workers*. " -"Habituellement un pool est créé à l'aide de la fonction :func:`multiprocessing.Pool` ou de la méthode :meth:" -"`Pool` d'un objet de contexte. Dans les deux cas *context* est réglé de façon appropriée." +"*context* peut être utilisé pour préciser le contexte utilisé pour démarrer " +"les processus *workers*. Habituellement un pool est créé à l'aide de la " +"fonction :func:`multiprocessing.Pool` ou de la méthode :meth:`Pool` d'un " +"objet de contexte. Dans les deux cas *context* est réglé de façon appropriée." #: library/multiprocessing.rst:2139 -msgid "Note that the methods of the pool object should only be called by the process which created the pool." -msgstr "Notez que les méthodes de l'objet *pool* ne doivent être appelées que par le processus qui l'a créé." +msgid "" +"Note that the methods of the pool object should only be called by the " +"process which created the pool." +msgstr "" +"Notez que les méthodes de l'objet *pool* ne doivent être appelées que par le " +"processus qui l'a créé." #: library/multiprocessing.rst:2143 msgid "" -":class:`multiprocessing.pool` objects have internal resources that need to be properly managed (like any other " -"resource) by using the pool as a context manager or by calling :meth:`close` and :meth:`terminate` manually. " -"Failure to do this can lead to the process hanging on finalization." +":class:`multiprocessing.pool` objects have internal resources that need to " +"be properly managed (like any other resource) by using the pool as a context " +"manager or by calling :meth:`close` and :meth:`terminate` manually. Failure " +"to do this can lead to the process hanging on finalization." msgstr "" -"Les objets :class:`multiprocessing.pool` ont des ressources internes qui doivent être correctement gérées (comme " -"toute autre ressource) en utilisant le pool comme gestionnaire de contexte ou en appelant :meth:`close` et :meth:" -"`terminate` manuellement. Si cela n'est pas fait, le processus peut être bloqué à la finalisation." +"Les objets :class:`multiprocessing.pool` ont des ressources internes qui " +"doivent être correctement gérées (comme toute autre ressource) en utilisant " +"le pool comme gestionnaire de contexte ou en appelant :meth:`close` et :meth:" +"`terminate` manuellement. Si cela n'est pas fait, le processus peut être " +"bloqué à la finalisation." #: library/multiprocessing.rst:2148 msgid "" -"Note that is **not correct** to rely on the garbage colletor to destroy the pool as CPython does not assure that " -"the finalizer of the pool will be called (see :meth:`object.__del__` for more information)." +"Note that is **not correct** to rely on the garbage colletor to destroy the " +"pool as CPython does not assure that the finalizer of the pool will be " +"called (see :meth:`object.__del__` for more information)." msgstr "" -"Notez qu'il n'est **pas correct** de compter sur le ramasse-miette pour détruire le pool car CPython n'assure pas " -"que le *finalizer* du pool sera appelé (voir :meth:`object.__del__` pour plus d'informations)." +"Notez qu'il n'est **pas correct** de compter sur le ramasse-miette pour " +"détruire le pool car CPython n'assure pas que le *finalizer* du pool sera " +"appelé (voir :meth:`object.__del__` pour plus d'informations)." #: library/multiprocessing.rst:2152 msgid "*maxtasksperchild*" @@ -2644,84 +3244,111 @@ msgstr "*context*" #: library/multiprocessing.rst:2160 msgid "" -"Worker processes within a :class:`Pool` typically live for the complete duration of the Pool's work queue. A " -"frequent pattern found in other systems (such as Apache, mod_wsgi, etc) to free resources held by workers is to " -"allow a worker within a pool to complete only a set amount of work before being exiting, being cleaned up and a " -"new process spawned to replace the old one. The *maxtasksperchild* argument to the :class:`Pool` exposes this " +"Worker processes within a :class:`Pool` typically live for the complete " +"duration of the Pool's work queue. A frequent pattern found in other systems " +"(such as Apache, mod_wsgi, etc) to free resources held by workers is to " +"allow a worker within a pool to complete only a set amount of work before " +"being exiting, being cleaned up and a new process spawned to replace the old " +"one. The *maxtasksperchild* argument to the :class:`Pool` exposes this " "ability to the end user." msgstr "" -"Les processus *workers* à l'intérieur d'une :class:`Pool` vivent par défaut aussi longtemps que la file de " -"travail du pool. Un modèle fréquent chez d'autres systèmes (tels qu'Apache, *mod_wsgi*, etc.) pour libérer les " -"ressources détenues par les *workers* est d'autoriser un *worker* dans le pool à accomplir seulement une certaine " -"charge de travail avant de se fermer, se retrouvant nettoyé et remplacé par un nouveau processus fraîchement " -"lancé. L'argument *maxtasksperchild* de :class:`Pool` expose cette fonctionnalité à l'utilisateur final." +"Les processus *workers* à l'intérieur d'une :class:`Pool` vivent par défaut " +"aussi longtemps que la file de travail du pool. Un modèle fréquent chez " +"d'autres systèmes (tels qu'Apache, *mod_wsgi*, etc.) pour libérer les " +"ressources détenues par les *workers* est d'autoriser un *worker* dans le " +"pool à accomplir seulement une certaine charge de travail avant de se " +"fermer, se retrouvant nettoyé et remplacé par un nouveau processus " +"fraîchement lancé. L'argument *maxtasksperchild* de :class:`Pool` expose " +"cette fonctionnalité à l'utilisateur final." #: library/multiprocessing.rst:2170 msgid "" -"Call *func* with arguments *args* and keyword arguments *kwds*. It blocks until the result is ready. Given this " -"blocks, :meth:`apply_async` is better suited for performing work in parallel. Additionally, *func* is only " +"Call *func* with arguments *args* and keyword arguments *kwds*. It blocks " +"until the result is ready. Given this blocks, :meth:`apply_async` is better " +"suited for performing work in parallel. Additionally, *func* is only " "executed in one of the workers of the pool." msgstr "" -"Appelle *func* avec les arguments *args* et les arguments nommés *kwds*. Bloque jusqu'à ce que que le résultat " -"soit prêt. En raison de ce blocage, :meth:`apply_async` est préférable pour exécuter du travail en parallèle. De " +"Appelle *func* avec les arguments *args* et les arguments nommés *kwds*. " +"Bloque jusqu'à ce que que le résultat soit prêt. En raison de ce blocage, :" +"meth:`apply_async` est préférable pour exécuter du travail en parallèle. De " "plus, *func* est exécutée sur un seul des *workers* du pool." #: library/multiprocessing.rst:2177 -msgid "A variant of the :meth:`apply` method which returns a :class:`~multiprocessing.pool.AsyncResult` object." -msgstr "Une variante de la méthode :meth:`apply` qui renvoie un objet :class:`~multiprocessing.pool.AsyncResult`." +msgid "" +"A variant of the :meth:`apply` method which returns a :class:" +"`~multiprocessing.pool.AsyncResult` object." +msgstr "" +"Une variante de la méthode :meth:`apply` qui renvoie un objet :class:" +"`~multiprocessing.pool.AsyncResult`." #: library/multiprocessing.rst:2180 library/multiprocessing.rst:2211 msgid "" -"If *callback* is specified then it should be a callable which accepts a single argument. When the result becomes " -"ready *callback* is applied to it, that is unless the call failed, in which case the *error_callback* is applied " -"instead." +"If *callback* is specified then it should be a callable which accepts a " +"single argument. When the result becomes ready *callback* is applied to it, " +"that is unless the call failed, in which case the *error_callback* is " +"applied instead." msgstr "" -"Si *callback* est précisé alors ce doit être un objet appelable qui accepte un seul argument. Quand le résultat " -"est prêt, *callback* est appelé avec ce résultat, si l'appel n'échoue pas auquel cas *error_callback* est appelé " -"à la place." +"Si *callback* est précisé alors ce doit être un objet appelable qui accepte " +"un seul argument. Quand le résultat est prêt, *callback* est appelé avec ce " +"résultat, si l'appel n'échoue pas auquel cas *error_callback* est appelé à " +"la place." #: library/multiprocessing.rst:2185 library/multiprocessing.rst:2216 msgid "" -"If *error_callback* is specified then it should be a callable which accepts a single argument. If the target " -"function fails, then the *error_callback* is called with the exception instance." +"If *error_callback* is specified then it should be a callable which accepts " +"a single argument. If the target function fails, then the *error_callback* " +"is called with the exception instance." msgstr "" -"Si *error_callback* est précisé alors ce doit être un objet appelable qui accepte un seul argument. Si la " -"fonction cible échoue, alors *error_callback* est appelé avec l'instance de l'exception." +"Si *error_callback* est précisé alors ce doit être un objet appelable qui " +"accepte un seul argument. Si la fonction cible échoue, alors " +"*error_callback* est appelé avec l'instance de l'exception." #: library/multiprocessing.rst:2189 library/multiprocessing.rst:2220 -msgid "Callbacks should complete immediately since otherwise the thread which handles the results will get blocked." +msgid "" +"Callbacks should complete immediately since otherwise the thread which " +"handles the results will get blocked." msgstr "" -"Les *callbacks* doivent se terminer immédiatement, autrement le fil d'exécution qui gère les résultats se " -"retrouverait bloqué." +"Les *callbacks* doivent se terminer immédiatement, autrement le fil " +"d'exécution qui gère les résultats se retrouverait bloqué." #: library/multiprocessing.rst:2194 msgid "" -"A parallel equivalent of the :func:`map` built-in function (it supports only one *iterable* argument though, for " -"multiple iterables see :meth:`starmap`). It blocks until the result is ready." +"A parallel equivalent of the :func:`map` built-in function (it supports only " +"one *iterable* argument though, for multiple iterables see :meth:`starmap`). " +"It blocks until the result is ready." msgstr "" -"Un équivalent parallèle de la fonction native :func:`map` (qui ne prend qu'un seul argument *itérable* ; pour en " -"passer plusieurs, référez-vous à :meth:`starmap`). Elle bloque jusqu'à ce que le résultat soit prêt." +"Un équivalent parallèle de la fonction native :func:`map` (qui ne prend " +"qu'un seul argument *itérable* ; pour en passer plusieurs, référez-vous à :" +"meth:`starmap`). Elle bloque jusqu'à ce que le résultat soit prêt." #: library/multiprocessing.rst:2198 msgid "" -"This method chops the iterable into a number of chunks which it submits to the process pool as separate tasks. " -"The (approximate) size of these chunks can be specified by setting *chunksize* to a positive integer." +"This method chops the iterable into a number of chunks which it submits to " +"the process pool as separate tasks. The (approximate) size of these chunks " +"can be specified by setting *chunksize* to a positive integer." msgstr "" -"La méthode découpe l'itérable en un nombre de morceaux qu'elle envoie au pool de processus comme des tâches " -"séparées. La taille (approximative) de ces morceaux peut être précisée en passant à *chunksize* un entier positif." +"La méthode découpe l'itérable en un nombre de morceaux qu'elle envoie au " +"pool de processus comme des tâches séparées. La taille (approximative) de " +"ces morceaux peut être précisée en passant à *chunksize* un entier positif." #: library/multiprocessing.rst:2202 msgid "" -"Note that it may cause high memory usage for very long iterables. Consider using :meth:`imap` or :meth:" -"`imap_unordered` with explicit *chunksize* option for better efficiency." +"Note that it may cause high memory usage for very long iterables. Consider " +"using :meth:`imap` or :meth:`imap_unordered` with explicit *chunksize* " +"option for better efficiency." msgstr "" -"Notez que cela peut entraîner une grosse consommation de mémoire pour les itérables très longs. Envisagez " -"d'utiliser :meth:`imap` ou :meth:`imap_unordered` avec l'option *chunksize* explicite pour une meilleure " +"Notez que cela peut entraîner une grosse consommation de mémoire pour les " +"itérables très longs. Envisagez d'utiliser :meth:`imap` ou :meth:" +"`imap_unordered` avec l'option *chunksize* explicite pour une meilleure " "efficacité." #: library/multiprocessing.rst:2208 -msgid "A variant of the :meth:`.map` method which returns a :class:`~multiprocessing.pool.AsyncResult` object." -msgstr "Une variante de la méthode :meth:`.map` qui renvoie un objet :class:`~multiprocessing.pool.AsyncResult`." +msgid "" +"A variant of the :meth:`.map` method which returns a :class:" +"`~multiprocessing.pool.AsyncResult` object." +msgstr "" +"Une variante de la méthode :meth:`.map` qui renvoie un objet :class:" +"`~multiprocessing.pool.AsyncResult`." #: library/multiprocessing.rst:2225 msgid "A lazier version of :meth:`.map`." @@ -2729,101 +3356,124 @@ msgstr "Une version paresseuse de :meth:`map`." #: library/multiprocessing.rst:2227 msgid "" -"The *chunksize* argument is the same as the one used by the :meth:`.map` method. For very long iterables using a " -"large value for *chunksize* can make the job complete **much** faster than using the default value of ``1``." +"The *chunksize* argument is the same as the one used by the :meth:`.map` " +"method. For very long iterables using a large value for *chunksize* can " +"make the job complete **much** faster than using the default value of ``1``." msgstr "" -"L'argument *chunksize* est le même que celui utilisé par la méthode :meth:`.map`. Pour de très longs itérables, " -"utiliser une grande valeur pour *chunksize* peut faire s'exécuter la tâche **beaucoup** plus rapidement qu'en " -"utilisant la valeur par défaut de ``1``." +"L'argument *chunksize* est le même que celui utilisé par la méthode :meth:`." +"map`. Pour de très longs itérables, utiliser une grande valeur pour " +"*chunksize* peut faire s'exécuter la tâche **beaucoup** plus rapidement " +"qu'en utilisant la valeur par défaut de ``1``." #: library/multiprocessing.rst:2232 msgid "" -"Also if *chunksize* is ``1`` then the :meth:`!next` method of the iterator returned by the :meth:`imap` method " -"has an optional *timeout* parameter: ``next(timeout)`` will raise :exc:`multiprocessing.TimeoutError` if the " +"Also if *chunksize* is ``1`` then the :meth:`!next` method of the iterator " +"returned by the :meth:`imap` method has an optional *timeout* parameter: " +"``next(timeout)`` will raise :exc:`multiprocessing.TimeoutError` if the " "result cannot be returned within *timeout* seconds." msgstr "" -"Aussi, si *chucksize* vaut ``1`` alors la méthode :meth:`!next` de l'itérateur renvoyé par :meth:`imap` prend un " -"paramètre optionnel *timeout* : ``next(timeout)`` lève une :exc:`multiprocessing.TimeoutError` si le résultat ne " -"peut pas être renvoyé avant *timeout* secondes." +"Aussi, si *chucksize* vaut ``1`` alors la méthode :meth:`!next` de " +"l'itérateur renvoyé par :meth:`imap` prend un paramètre optionnel " +"*timeout* : ``next(timeout)`` lève une :exc:`multiprocessing.TimeoutError` " +"si le résultat ne peut pas être renvoyé avant *timeout* secondes." #: library/multiprocessing.rst:2239 msgid "" -"The same as :meth:`imap` except that the ordering of the results from the returned iterator should be considered " -"arbitrary. (Only when there is only one worker process is the order guaranteed to be \"correct\".)" +"The same as :meth:`imap` except that the ordering of the results from the " +"returned iterator should be considered arbitrary. (Only when there is only " +"one worker process is the order guaranteed to be \"correct\".)" msgstr "" -"Identique à :meth:`imap` si ce n'est que l'ordre des résultats de l'itérateur renvoyé doit être considéré comme " -"arbitraire. (L'ordre n'est garanti que quand il n'y a qu'un *worker*.)" +"Identique à :meth:`imap` si ce n'est que l'ordre des résultats de " +"l'itérateur renvoyé doit être considéré comme arbitraire. (L'ordre n'est " +"garanti que quand il n'y a qu'un *worker*.)" #: library/multiprocessing.rst:2245 msgid "" -"Like :meth:`map` except that the elements of the *iterable* are expected to be iterables that are unpacked as " -"arguments." +"Like :meth:`map` except that the elements of the *iterable* are expected to " +"be iterables that are unpacked as arguments." msgstr "" -"Semblable à :meth:`map` à l'exception que les éléments d'*iterable* doivent être des itérables qui seront " -"dépaquetés comme arguments pour la fonction." +"Semblable à :meth:`map` à l'exception que les éléments d'*iterable* doivent " +"être des itérables qui seront dépaquetés comme arguments pour la fonction." #: library/multiprocessing.rst:2248 -msgid "Hence an *iterable* of ``[(1,2), (3, 4)]`` results in ``[func(1,2), func(3,4)]``." -msgstr "Par conséquent un *iterable* ``[(1,2), (3, 4)]`` donnera pour résultat ``[func(1,2), func(3,4)]``." +msgid "" +"Hence an *iterable* of ``[(1,2), (3, 4)]`` results in ``[func(1,2), " +"func(3,4)]``." +msgstr "" +"Par conséquent un *iterable* ``[(1,2), (3, 4)]`` donnera pour résultat " +"``[func(1,2), func(3,4)]``." #: library/multiprocessing.rst:2255 msgid "" -"A combination of :meth:`starmap` and :meth:`map_async` that iterates over *iterable* of iterables and calls " -"*func* with the iterables unpacked. Returns a result object." +"A combination of :meth:`starmap` and :meth:`map_async` that iterates over " +"*iterable* of iterables and calls *func* with the iterables unpacked. " +"Returns a result object." msgstr "" -"Une combinaison de :meth:`starmap` et :meth:`map_async` qui itère sur *iterable* (composé d'itérables) et appelle " -"*func* pour chaque itérable dépaqueté. Renvoie l'objet résultat." +"Une combinaison de :meth:`starmap` et :meth:`map_async` qui itère sur " +"*iterable* (composé d'itérables) et appelle *func* pour chaque itérable " +"dépaqueté. Renvoie l'objet résultat." #: library/multiprocessing.rst:2263 msgid "" -"Prevents any more tasks from being submitted to the pool. Once all the tasks have been completed the worker " -"processes will exit." +"Prevents any more tasks from being submitted to the pool. Once all the " +"tasks have been completed the worker processes will exit." msgstr "" -"Empêche de nouvelles tâches d'être envoyées à la *pool*. Les processus *workers* se terminent une fois que toutes " -"les tâches ont été complétées." +"Empêche de nouvelles tâches d'être envoyées à la *pool*. Les processus " +"*workers* se terminent une fois que toutes les tâches ont été complétées." #: library/multiprocessing.rst:2268 msgid "" -"Stops the worker processes immediately without completing outstanding work. When the pool object is garbage " -"collected :meth:`terminate` will be called immediately." +"Stops the worker processes immediately without completing outstanding work. " +"When the pool object is garbage collected :meth:`terminate` will be called " +"immediately." msgstr "" -"Stoppe immédiatement les processus *workers* sans finaliser les travaux courants. Quand l'objet *pool* est " -"collecté par le ramasse-miettes, sa méthode :meth:`terminate` est appelée immédiatement." +"Stoppe immédiatement les processus *workers* sans finaliser les travaux " +"courants. Quand l'objet *pool* est collecté par le ramasse-miettes, sa " +"méthode :meth:`terminate` est appelée immédiatement." #: library/multiprocessing.rst:2274 msgid "" -"Wait for the worker processes to exit. One must call :meth:`close` or :meth:`terminate` before using :meth:" -"`join`." +"Wait for the worker processes to exit. One must call :meth:`close` or :meth:" +"`terminate` before using :meth:`join`." msgstr "" -"Attend que les processus *workers* se terminent. Il est nécessaire d'appeler :meth:`close` ou :meth:`terminate` " -"avant d'utiliser :meth:`join`." +"Attend que les processus *workers* se terminent. Il est nécessaire " +"d'appeler :meth:`close` ou :meth:`terminate` avant d'utiliser :meth:`join`." #: library/multiprocessing.rst:2277 msgid "" -"Pool objects now support the context management protocol -- see :ref:`typecontextmanager`. :meth:" -"`~contextmanager.__enter__` returns the pool object, and :meth:`~contextmanager.__exit__` calls :meth:`terminate`." +"Pool objects now support the context management protocol -- see :ref:" +"`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the pool " +"object, and :meth:`~contextmanager.__exit__` calls :meth:`terminate`." msgstr "" -"Les pools de *workers* supportent maintenant le protocole des gestionnaires de contexte – voir :ref:" -"`typecontextmanager`. :meth:`~contextmanager.__enter__` renvoie l'objet *pool* et :meth:`~contextmanager." -"__exit__` appelle :meth:`terminate`." +"Les pools de *workers* supportent maintenant le protocole des gestionnaires " +"de contexte – voir :ref:`typecontextmanager`. :meth:`~contextmanager." +"__enter__` renvoie l'objet *pool* et :meth:`~contextmanager.__exit__` " +"appelle :meth:`terminate`." #: library/multiprocessing.rst:2285 -msgid "The class of the result returned by :meth:`Pool.apply_async` and :meth:`Pool.map_async`." -msgstr "La classe des résultats renvoyés par :meth:`Pool.apply_async` et :meth:`Pool.map_async`." +msgid "" +"The class of the result returned by :meth:`Pool.apply_async` and :meth:`Pool." +"map_async`." +msgstr "" +"La classe des résultats renvoyés par :meth:`Pool.apply_async` et :meth:`Pool." +"map_async`." #: library/multiprocessing.rst:2290 msgid "" -"Return the result when it arrives. If *timeout* is not ``None`` and the result does not arrive within *timeout* " -"seconds then :exc:`multiprocessing.TimeoutError` is raised. If the remote call raised an exception then that " +"Return the result when it arrives. If *timeout* is not ``None`` and the " +"result does not arrive within *timeout* seconds then :exc:`multiprocessing." +"TimeoutError` is raised. If the remote call raised an exception then that " "exception will be reraised by :meth:`get`." msgstr "" -"Renvoie le résultat quand il arrive. Si *timeout* n'est pas ``None`` et que le résultat n'arrive pas avant " -"*timeout* secondes, une :exc:`multiprocessing.TimeoutError` est levée. Si l'appel distance lève une exception, " -"alors elle est relayée par :meth:`get`." +"Renvoie le résultat quand il arrive. Si *timeout* n'est pas ``None`` et que " +"le résultat n'arrive pas avant *timeout* secondes, une :exc:`multiprocessing." +"TimeoutError` est levée. Si l'appel distance lève une exception, alors elle " +"est relayée par :meth:`get`." #: library/multiprocessing.rst:2297 msgid "Wait until the result is available or until *timeout* seconds pass." -msgstr "Attend que le résultat soit disponible ou que *timeout* secondes s'écoulent." +msgstr "" +"Attend que le résultat soit disponible ou que *timeout* secondes s'écoulent." #: library/multiprocessing.rst:2301 msgid "Return whether the call has completed." @@ -2831,20 +3481,24 @@ msgstr "Renvoie ``True`` ou ``False`` suivant si la tâche est accomplie." #: library/multiprocessing.rst:2305 msgid "" -"Return whether the call completed without raising an exception. Will raise :exc:`ValueError` if the result is " -"not ready." +"Return whether the call completed without raising an exception. Will raise :" +"exc:`ValueError` if the result is not ready." msgstr "" -"Renvoie ``True`` ou ``False`` suivant si la tâche est accomplie sans lever d'exception. Lève une :exc:" -"`ValueError` si le résultat n'est pas prêt." +"Renvoie ``True`` ou ``False`` suivant si la tâche est accomplie sans lever " +"d'exception. Lève une :exc:`ValueError` si le résultat n'est pas prêt." #: library/multiprocessing.rst:2308 -msgid "If the result is not ready, :exc:`ValueError` is raised instead of :exc:`AssertionError`." +msgid "" +"If the result is not ready, :exc:`ValueError` is raised instead of :exc:" +"`AssertionError`." msgstr "" -"Si le résultat n'est pas prêt, une :exc:`ValueError` est levée au lieu d'une :exc:`AssertionError` auparavant." +"Si le résultat n'est pas prêt, une :exc:`ValueError` est levée au lieu " +"d'une :exc:`AssertionError` auparavant." #: library/multiprocessing.rst:2312 msgid "The following example demonstrates the use of a pool::" -msgstr "Les exemples suivants présentent l'utilisation d'un pool de *workers* ::" +msgstr "" +"Les exemples suivants présentent l'utilisation d'un pool de *workers* ::" #: library/multiprocessing.rst:2339 msgid "Listeners and Clients" @@ -2852,206 +3506,276 @@ msgstr "Auditeurs et Clients" #: library/multiprocessing.rst:2344 msgid "" -"Usually message passing between processes is done using queues or by using :class:`~Connection` objects returned " -"by :func:`~multiprocessing.Pipe`." +"Usually message passing between processes is done using queues or by using :" +"class:`~Connection` objects returned by :func:`~multiprocessing.Pipe`." msgstr "" -"Habituellement l'échange de messages entre processus est réalisé en utilisant des files ou des objets :class:" -"`~Connection` renvoyés par :func:`~multiprocessing.Pipe`." +"Habituellement l'échange de messages entre processus est réalisé en " +"utilisant des files ou des objets :class:`~Connection` renvoyés par :func:" +"`~multiprocessing.Pipe`." #: library/multiprocessing.rst:2348 msgid "" -"However, the :mod:`multiprocessing.connection` module allows some extra flexibility. It basically gives a high " -"level message oriented API for dealing with sockets or Windows named pipes. It also has support for *digest " -"authentication* using the :mod:`hmac` module, and for polling multiple connections at the same time." +"However, the :mod:`multiprocessing.connection` module allows some extra " +"flexibility. It basically gives a high level message oriented API for " +"dealing with sockets or Windows named pipes. It also has support for " +"*digest authentication* using the :mod:`hmac` module, and for polling " +"multiple connections at the same time." msgstr "" -"Cependant, le module :mod:`multiprocessing.connection` permet un peu plus de flexibilité. Il fournit un message " -"de plus haut-niveau orienté API pour gérer des connecteurs ou des tubes nommés sous Windows. Il gère aussi " -"l'authentification par condensat (*digest authentication* en anglais) en utilisant le module :mod:`hmac`, et pour " -"interroger de multiples connexions en même temps." +"Cependant, le module :mod:`multiprocessing.connection` permet un peu plus de " +"flexibilité. Il fournit un message de plus haut-niveau orienté API pour " +"gérer des connecteurs ou des tubes nommés sous Windows. Il gère aussi " +"l'authentification par condensat (*digest authentication* en anglais) en " +"utilisant le module :mod:`hmac`, et pour interroger de multiples connexions " +"en même temps." #: library/multiprocessing.rst:2357 -msgid "Send a randomly generated message to the other end of the connection and wait for a reply." -msgstr "Envoie un message généré aléatoirement à l'autre bout de la connexion et attend une réponse." +msgid "" +"Send a randomly generated message to the other end of the connection and " +"wait for a reply." +msgstr "" +"Envoie un message généré aléatoirement à l'autre bout de la connexion et " +"attend une réponse." #: library/multiprocessing.rst:2360 msgid "" -"If the reply matches the digest of the message using *authkey* as the key then a welcome message is sent to the " -"other end of the connection. Otherwise :exc:`~multiprocessing.AuthenticationError` is raised." +"If the reply matches the digest of the message using *authkey* as the key " +"then a welcome message is sent to the other end of the connection. " +"Otherwise :exc:`~multiprocessing.AuthenticationError` is raised." msgstr "" -"Si la réponse correspond au condensat du message avec la clé *authkey*, alors un message de bienvenue est envoyé " -"à l'autre bout de la connexion. Autrement, une :exc:`~multiprocessing.AuthenticationError` est levée." +"Si la réponse correspond au condensat du message avec la clé *authkey*, " +"alors un message de bienvenue est envoyé à l'autre bout de la connexion. " +"Autrement, une :exc:`~multiprocessing.AuthenticationError` est levée." #: library/multiprocessing.rst:2366 msgid "" -"Receive a message, calculate the digest of the message using *authkey* as the key, and then send the digest back." +"Receive a message, calculate the digest of the message using *authkey* as " +"the key, and then send the digest back." msgstr "" -"Reçoit un message, calcule le condensat du message en utilisant la clé *authkey*, et envoie le condensat en " -"réponse." +"Reçoit un message, calcule le condensat du message en utilisant la clé " +"*authkey*, et envoie le condensat en réponse." #: library/multiprocessing.rst:2369 -msgid "If a welcome message is not received, then :exc:`~multiprocessing.AuthenticationError` is raised." -msgstr "Si un message de bienvenue n'est pas reçu, une :exc:`~multiprocessing.AuthenticationError` est levée." +msgid "" +"If a welcome message is not received, then :exc:`~multiprocessing." +"AuthenticationError` is raised." +msgstr "" +"Si un message de bienvenue n'est pas reçu, une :exc:`~multiprocessing." +"AuthenticationError` est levée." #: library/multiprocessing.rst:2374 msgid "" -"Attempt to set up a connection to the listener which is using address *address*, returning a :class:`~Connection`." +"Attempt to set up a connection to the listener which is using address " +"*address*, returning a :class:`~Connection`." msgstr "" -"Essaie d'établir une connexion avec l'auditeur qui utilise l'adresse *address*, renvoie une :class:`~Connection`." +"Essaie d'établir une connexion avec l'auditeur qui utilise l'adresse " +"*address*, renvoie une :class:`~Connection`." #: library/multiprocessing.rst:2377 msgid "" -"The type of the connection is determined by *family* argument, but this can generally be omitted since it can " -"usually be inferred from the format of *address*. (See :ref:`multiprocessing-address-formats`)" +"The type of the connection is determined by *family* argument, but this can " +"generally be omitted since it can usually be inferred from the format of " +"*address*. (See :ref:`multiprocessing-address-formats`)" msgstr "" -"Le type de la connexion est déterminé par l'argument *family*, mais il peut généralement être omis puisqu'il peut " -"être inféré depuis le format d'*address*. (Voir :ref:`multiprocessing-address-formats`)" +"Le type de la connexion est déterminé par l'argument *family*, mais il peut " +"généralement être omis puisqu'il peut être inféré depuis le format " +"d'*address*. (Voir :ref:`multiprocessing-address-formats`)" #: library/multiprocessing.rst:2381 library/multiprocessing.rst:2416 msgid "" -"If *authkey* is given and not None, it should be a byte string and will be used as the secret key for an HMAC-" -"based authentication challenge. No authentication is done if *authkey* is None. :exc:`~multiprocessing." -"AuthenticationError` is raised if authentication fails. See :ref:`multiprocessing-auth-keys`." -msgstr "" -"Si *authkey* est passée et n'est pas ``None``, elle doit être une chaîne d'octets et sera utilisée comme clé " -"secrète pour le défi d'authentification basé sur HMAC. Aucune authentification n'est réalisée si *authkey* est " -"``None``. Une :exc:`~multiprocessing.AuthenticationError` est levée si l'authentification échoue. Voir :ref:" +"If *authkey* is given and not None, it should be a byte string and will be " +"used as the secret key for an HMAC-based authentication challenge. No " +"authentication is done if *authkey* is None. :exc:`~multiprocessing." +"AuthenticationError` is raised if authentication fails. See :ref:" "`multiprocessing-auth-keys`." +msgstr "" +"Si *authkey* est passée et n'est pas ``None``, elle doit être une chaîne " +"d'octets et sera utilisée comme clé secrète pour le défi d'authentification " +"basé sur HMAC. Aucune authentification n'est réalisée si *authkey* est " +"``None``. Une :exc:`~multiprocessing.AuthenticationError` est levée si " +"l'authentification échoue. Voir :ref:`multiprocessing-auth-keys`." #: library/multiprocessing.rst:2389 -msgid "A wrapper for a bound socket or Windows named pipe which is 'listening' for connections." -msgstr "Une enveloppe autour d'un connecteur lié ou un tube nommé sous Windows qui écoute pour des connexions." +msgid "" +"A wrapper for a bound socket or Windows named pipe which is 'listening' for " +"connections." +msgstr "" +"Une enveloppe autour d'un connecteur lié ou un tube nommé sous Windows qui " +"écoute pour des connexions." #: library/multiprocessing.rst:2392 -msgid "*address* is the address to be used by the bound socket or named pipe of the listener object." -msgstr "*address* est l'adresse à utiliser par le connecteur lié ou le tube nommé de l'objet auditeur." +msgid "" +"*address* is the address to be used by the bound socket or named pipe of the " +"listener object." +msgstr "" +"*address* est l'adresse à utiliser par le connecteur lié ou le tube nommé de " +"l'objet auditeur." #: library/multiprocessing.rst:2397 msgid "" -"If an address of '0.0.0.0' is used, the address will not be a connectable end point on Windows. If you require a " -"connectable end-point, you should use '127.0.0.1'." +"If an address of '0.0.0.0' is used, the address will not be a connectable " +"end point on Windows. If you require a connectable end-point, you should use " +"'127.0.0.1'." msgstr "" -"Si une adresse '0.0.0.0' est utilisée, l'adresse ne sera pas un point d'accès connectable sous Windows. Si vous " -"avez besoin d'un point d'accès connectable, utilisez '127.0.0.1'." +"Si une adresse '0.0.0.0' est utilisée, l'adresse ne sera pas un point " +"d'accès connectable sous Windows. Si vous avez besoin d'un point d'accès " +"connectable, utilisez '127.0.0.1'." #: library/multiprocessing.rst:2401 msgid "" -"*family* is the type of socket (or named pipe) to use. This can be one of the strings ``'AF_INET'`` (for a TCP " -"socket), ``'AF_UNIX'`` (for a Unix domain socket) or ``'AF_PIPE'`` (for a Windows named pipe). Of these only the " -"first is guaranteed to be available. If *family* is ``None`` then the family is inferred from the format of " -"*address*. If *address* is also ``None`` then a default is chosen. This default is the family which is assumed " -"to be the fastest available. See :ref:`multiprocessing-address-formats`. Note that if *family* is ``'AF_UNIX'`` " -"and address is ``None`` then the socket will be created in a private temporary directory created using :func:" -"`tempfile.mkstemp`." -msgstr "" -"*family* est le type de connecteur (ou tube nommé) à utiliser. Cela peut être l'une des chaînes ``'AF_INET'`` " -"(pour un connecteur TCP), ``'AF_UNIX'`` (pour un connecteur Unix) ou ``'AF_PIPE'`` (pour un tube nommé sous " -"Windows). Seulement le premier d'entre eux est garanti d'être disponible. Si *family* est ``None``, la famille " -"est inférée depuis le format d'*address*. Si *address* est aussi ``None``, la famille par défaut est utilisée. La " -"famille par défaut est supposée être la plus rapide disponible. Voir :ref:`multiprocessing-address-formats`. " -"Notez que si la *family* est ``'AF_UNIX'`` et qu'*address* est ``None``, le connecteur est créé dans un " +"*family* is the type of socket (or named pipe) to use. This can be one of " +"the strings ``'AF_INET'`` (for a TCP socket), ``'AF_UNIX'`` (for a Unix " +"domain socket) or ``'AF_PIPE'`` (for a Windows named pipe). Of these only " +"the first is guaranteed to be available. If *family* is ``None`` then the " +"family is inferred from the format of *address*. If *address* is also " +"``None`` then a default is chosen. This default is the family which is " +"assumed to be the fastest available. See :ref:`multiprocessing-address-" +"formats`. Note that if *family* is ``'AF_UNIX'`` and address is ``None`` " +"then the socket will be created in a private temporary directory created " +"using :func:`tempfile.mkstemp`." +msgstr "" +"*family* est le type de connecteur (ou tube nommé) à utiliser. Cela peut " +"être l'une des chaînes ``'AF_INET'`` (pour un connecteur TCP), ``'AF_UNIX'`` " +"(pour un connecteur Unix) ou ``'AF_PIPE'`` (pour un tube nommé sous " +"Windows). Seulement le premier d'entre eux est garanti d'être disponible. Si " +"*family* est ``None``, la famille est inférée depuis le format d'*address*. " +"Si *address* est aussi ``None``, la famille par défaut est utilisée. La " +"famille par défaut est supposée être la plus rapide disponible. Voir :ref:" +"`multiprocessing-address-formats`. Notez que si la *family* est " +"``'AF_UNIX'`` et qu'*address* est ``None``, le connecteur est créé dans un " "répertoire temporaire privé créé avec :func:`tempfile.mkstemp`." #: library/multiprocessing.rst:2412 msgid "" -"If the listener object uses a socket then *backlog* (1 by default) is passed to the :meth:`~socket.socket.listen` " -"method of the socket once it has been bound." +"If the listener object uses a socket then *backlog* (1 by default) is passed " +"to the :meth:`~socket.socket.listen` method of the socket once it has been " +"bound." msgstr "" -"Si l'objet auditeur utilise un connecteur alors *backlog* (1 par défaut) est passé à la méthode :meth:`~socket." -"socket.listen` du connecteur une fois qu'il a été lié." +"Si l'objet auditeur utilise un connecteur alors *backlog* (1 par défaut) est " +"passé à la méthode :meth:`~socket.socket.listen` du connecteur une fois " +"qu'il a été lié." #: library/multiprocessing.rst:2424 msgid "" -"Accept a connection on the bound socket or named pipe of the listener object and return a :class:`~Connection` " -"object. If authentication is attempted and fails, then :exc:`~multiprocessing.AuthenticationError` is raised." +"Accept a connection on the bound socket or named pipe of the listener object " +"and return a :class:`~Connection` object. If authentication is attempted and " +"fails, then :exc:`~multiprocessing.AuthenticationError` is raised." msgstr "" -"Accepte une connexion sur le connecteur lié ou le tube nommé de l'objet auditeur et renvoie un objet :class:" -"`~Connection`. Si la tentative d'authentification échoue, une :exc:`~multiprocessing.AuthenticationError` est " -"levée." +"Accepte une connexion sur le connecteur lié ou le tube nommé de l'objet " +"auditeur et renvoie un objet :class:`~Connection`. Si la tentative " +"d'authentification échoue, une :exc:`~multiprocessing.AuthenticationError` " +"est levée." #: library/multiprocessing.rst:2431 msgid "" -"Close the bound socket or named pipe of the listener object. This is called automatically when the listener is " -"garbage collected. However it is advisable to call it explicitly." +"Close the bound socket or named pipe of the listener object. This is called " +"automatically when the listener is garbage collected. However it is " +"advisable to call it explicitly." msgstr "" -"Ferme le connecteur lié ou le tube nommé de l'objet auditeur. La méthode est appelée automatiquement quand " -"l'auditeur est collecté par le ramasse-miettes. Il est cependant conseillé de l'appeler explicitement." +"Ferme le connecteur lié ou le tube nommé de l'objet auditeur. La méthode est " +"appelée automatiquement quand l'auditeur est collecté par le ramasse-" +"miettes. Il est cependant conseillé de l'appeler explicitement." #: library/multiprocessing.rst:2435 msgid "Listener objects have the following read-only properties:" -msgstr "Les objets auditeurs ont aussi les propriétés en lecture seule suivantes :" +msgstr "" +"Les objets auditeurs ont aussi les propriétés en lecture seule suivantes :" #: library/multiprocessing.rst:2439 msgid "The address which is being used by the Listener object." msgstr "L'adresse utilisée par l'objet auditeur." #: library/multiprocessing.rst:2443 -msgid "The address from which the last accepted connection came. If this is unavailable then it is ``None``." -msgstr "L'adresse depuis laquelle a été établie la dernière connexion. ``None`` si aucune n'est disponible." +msgid "" +"The address from which the last accepted connection came. If this is " +"unavailable then it is ``None``." +msgstr "" +"L'adresse depuis laquelle a été établie la dernière connexion. ``None`` si " +"aucune n'est disponible." #: library/multiprocessing.rst:2446 msgid "" -"Listener objects now support the context management protocol -- see :ref:`typecontextmanager`. :meth:" -"`~contextmanager.__enter__` returns the listener object, and :meth:`~contextmanager.__exit__` calls :meth:`close`." +"Listener objects now support the context management protocol -- see :ref:" +"`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the " +"listener object, and :meth:`~contextmanager.__exit__` calls :meth:`close`." msgstr "" -"Les objets auditeurs supportent maintenant le protocole des gestionnaires de contexte – voir :ref:" -"`typecontextmanager`. :meth:`~contextmanager.__enter__` renvoie l'objet auditeur, et :meth:`~contextmanager." -"__exit__` appelle :meth:`close`." +"Les objets auditeurs supportent maintenant le protocole des gestionnaires de " +"contexte – voir :ref:`typecontextmanager`. :meth:`~contextmanager.__enter__` " +"renvoie l'objet auditeur, et :meth:`~contextmanager.__exit__` appelle :meth:" +"`close`." #: library/multiprocessing.rst:2453 msgid "" -"Wait till an object in *object_list* is ready. Returns the list of those objects in *object_list* which are " -"ready. If *timeout* is a float then the call blocks for at most that many seconds. If *timeout* is ``None`` " -"then it will block for an unlimited period. A negative timeout is equivalent to a zero timeout." +"Wait till an object in *object_list* is ready. Returns the list of those " +"objects in *object_list* which are ready. If *timeout* is a float then the " +"call blocks for at most that many seconds. If *timeout* is ``None`` then it " +"will block for an unlimited period. A negative timeout is equivalent to a " +"zero timeout." msgstr "" -"Attend qu'un objet d'*object_list* soit prêt. Renvoie la liste de ces objets d'*object_list* qui sont prêts. Si " -"*timeout* est un nombre flottant, l'appel bloquera au maximum ce nombre de secondes. Si *timeout* est ``None``, " -"l'appelle bloquera pour une durée non limitée. Un *timeout* négatif est équivalent à un *timeout* nul." +"Attend qu'un objet d'*object_list* soit prêt. Renvoie la liste de ces objets " +"d'*object_list* qui sont prêts. Si *timeout* est un nombre flottant, l'appel " +"bloquera au maximum ce nombre de secondes. Si *timeout* est ``None``, " +"l'appelle bloquera pour une durée non limitée. Un *timeout* négatif est " +"équivalent à un *timeout* nul." #: library/multiprocessing.rst:2459 -msgid "For both Unix and Windows, an object can appear in *object_list* if it is" -msgstr "Pour Unix et Windows, un objet peut apparaître dans *object_list* s'il est" +msgid "" +"For both Unix and Windows, an object can appear in *object_list* if it is" +msgstr "" +"Pour Unix et Windows, un objet peut apparaître dans *object_list* s'il est" #: library/multiprocessing.rst:2462 msgid "a readable :class:`~multiprocessing.connection.Connection` object;" -msgstr "un objet :class:`~multiprocessing.connection.Connection` accessible en lecture ;" +msgstr "" +"un objet :class:`~multiprocessing.connection.Connection` accessible en " +"lecture ;" #: library/multiprocessing.rst:2463 msgid "a connected and readable :class:`socket.socket` object; or" msgstr "un objet :class:`socket.socket` connecté et accessible en lecture ; ou" #: library/multiprocessing.rst:2464 -msgid "the :attr:`~multiprocessing.Process.sentinel` attribute of a :class:`~multiprocessing.Process` object." -msgstr "l'attribut :attr:`~multiprocessing.Process.sentinel` d'un objet :class:`~multiprocessing.Process`." +msgid "" +"the :attr:`~multiprocessing.Process.sentinel` attribute of a :class:" +"`~multiprocessing.Process` object." +msgstr "" +"l'attribut :attr:`~multiprocessing.Process.sentinel` d'un objet :class:" +"`~multiprocessing.Process`." #: library/multiprocessing.rst:2467 msgid "" -"A connection or socket object is ready when there is data available to be read from it, or the other end has been " -"closed." +"A connection or socket object is ready when there is data available to be " +"read from it, or the other end has been closed." msgstr "" -"Une connexion (*socket* en anglais) est prête quand il y a des données disponibles en lecture dessus, ou que " -"l'autre bout a été fermé." +"Une connexion (*socket* en anglais) est prête quand il y a des données " +"disponibles en lecture dessus, ou que l'autre bout a été fermé." #: library/multiprocessing.rst:2470 msgid "" -"**Unix**: ``wait(object_list, timeout)`` almost equivalent ``select.select(object_list, [], [], timeout)``. The " -"difference is that, if :func:`select.select` is interrupted by a signal, it can raise :exc:`OSError` with an " -"error number of ``EINTR``, whereas :func:`wait` will not." +"**Unix**: ``wait(object_list, timeout)`` almost equivalent ``select." +"select(object_list, [], [], timeout)``. The difference is that, if :func:" +"`select.select` is interrupted by a signal, it can raise :exc:`OSError` with " +"an error number of ``EINTR``, whereas :func:`wait` will not." msgstr "" -"**Unix**: ``wait(object_list, timeout)`` est en grande partie équivalente à ``select.select(object_list, [], [], " -"timeout)``. La différence est que, si :func:`select.select` est interrompue par un signal, elle peut lever une :" -"exc:`OSError` avec un numéro d'erreur ``EINTR``, alors que :func:`wait` ne le fera pas." +"**Unix**: ``wait(object_list, timeout)`` est en grande partie équivalente à " +"``select.select(object_list, [], [], timeout)``. La différence est que, si :" +"func:`select.select` est interrompue par un signal, elle peut lever une :exc:" +"`OSError` avec un numéro d'erreur ``EINTR``, alors que :func:`wait` ne le " +"fera pas." #: library/multiprocessing.rst:2476 msgid "" -"**Windows**: An item in *object_list* must either be an integer handle which is waitable (according to the " -"definition used by the documentation of the Win32 function ``WaitForMultipleObjects()``) or it can be an object " -"with a :meth:`fileno` method which returns a socket handle or pipe handle. (Note that pipe handles and socket " -"handles are **not** waitable handles.)" +"**Windows**: An item in *object_list* must either be an integer handle which " +"is waitable (according to the definition used by the documentation of the " +"Win32 function ``WaitForMultipleObjects()``) or it can be an object with a :" +"meth:`fileno` method which returns a socket handle or pipe handle. (Note " +"that pipe handles and socket handles are **not** waitable handles.)" msgstr "" -"**Windows** : un élément d'*object_list* doit être soit un identifiant *waitable* (en accord avec la définition " -"utilisée par la documentation de la fonction Win32 ``WaitForMultipleObjects()``), soit un objet avec une méthode :" -"meth:`fileno` qui renvoie un identifiant de connecteur ou de tube (notez que les identifiants de tubes et de " -"connecteurs **ne sont pas** des identifiants *waitables*)." +"**Windows** : un élément d'*object_list* doit être soit un identifiant " +"*waitable* (en accord avec la définition utilisée par la documentation de la " +"fonction Win32 ``WaitForMultipleObjects()``), soit un objet avec une " +"méthode :meth:`fileno` qui renvoie un identifiant de connecteur ou de tube " +"(notez que les identifiants de tubes et de connecteurs **ne sont pas** des " +"identifiants *waitables*)." #: library/multiprocessing.rst:2486 msgid "**Examples**" @@ -3059,23 +3783,27 @@ msgstr "**Exemples**" #: library/multiprocessing.rst:2488 msgid "" -"The following server code creates a listener which uses ``'secret password'`` as an authentication key. It then " -"waits for a connection and sends some data to the client::" +"The following server code creates a listener which uses ``'secret " +"password'`` as an authentication key. It then waits for a connection and " +"sends some data to the client::" msgstr "" -"Le code serveur suivant crée un auditeur qui utilise ``'secret password'`` comme clé d'authentification. Il " -"attend ensuite une connexion et envoie les données au client ::" +"Le code serveur suivant crée un auditeur qui utilise ``'secret password'`` " +"comme clé d'authentification. Il attend ensuite une connexion et envoie les " +"données au client ::" #: library/multiprocessing.rst:2507 -msgid "The following code connects to the server and receives some data from the server::" +msgid "" +"The following code connects to the server and receives some data from the " +"server::" msgstr "Le code suivant se connecte au serveur et en reçoit des données ::" #: library/multiprocessing.rst:2524 msgid "" -"The following code uses :func:`~multiprocessing.connection.wait` to wait for messages from multiple processes at " -"once::" +"The following code uses :func:`~multiprocessing.connection.wait` to wait for " +"messages from multiple processes at once::" msgstr "" -"Le code suivant utilise :func:`~multiprocessing.connection.wait` pour attendre des messages depuis plusieurs " -"processus à la fois ::" +"Le code suivant utilise :func:`~multiprocessing.connection.wait` pour " +"attendre des messages depuis plusieurs processus à la fois ::" #: library/multiprocessing.rst:2563 msgid "Address Formats" @@ -3083,33 +3811,41 @@ msgstr "Formats d'adresses" #: library/multiprocessing.rst:2565 msgid "" -"An ``'AF_INET'`` address is a tuple of the form ``(hostname, port)`` where *hostname* is a string and *port* is " -"an integer." +"An ``'AF_INET'`` address is a tuple of the form ``(hostname, port)`` where " +"*hostname* is a string and *port* is an integer." msgstr "" -"Une adresse ``'AF_INET'`` est une paire de la forme ``(hostname, port)`` où *hostname* est une chaîne et *port* " -"un entier." +"Une adresse ``'AF_INET'`` est une paire de la forme ``(hostname, port)`` où " +"*hostname* est une chaîne et *port* un entier." #: library/multiprocessing.rst:2568 -msgid "An ``'AF_UNIX'`` address is a string representing a filename on the filesystem." -msgstr "Une adresse ``'AF_UNIX'`` est une chaîne représentant un nom de fichier sur le système de fichiers." +msgid "" +"An ``'AF_UNIX'`` address is a string representing a filename on the " +"filesystem." +msgstr "" +"Une adresse ``'AF_UNIX'`` est une chaîne représentant un nom de fichier sur " +"le système de fichiers." #: library/multiprocessing.rst:2571 msgid "" -"An ``'AF_PIPE'`` address is a string of the form :samp:`r'\\\\\\\\.\\\\pipe\\\\{PipeName}'`. To use :func:" -"`Client` to connect to a named pipe on a remote computer called *ServerName* one should use an address of the " -"form :samp:`r'\\\\\\\\{ServerName}\\\\pipe\\\\{PipeName}'` instead." +"An ``'AF_PIPE'`` address is a string of the form :samp:`r'\\\\\\\\.\\\\pipe\\" +"\\{PipeName}'`. To use :func:`Client` to connect to a named pipe on a " +"remote computer called *ServerName* one should use an address of the form :" +"samp:`r'\\\\\\\\{ServerName}\\\\pipe\\\\{PipeName}'` instead." msgstr "" -"Une adresse ``'AF_PIPE'`` est une chaîne de caractères de la forme :samp:`r'\\\\\\\\.\\\\pipe\\\\{PipeName}'`. " -"Pour utiliser :func:`Client` pour se connecter à un tube nommé sur une machine distante appelée *ServerName*, il " -"faut utiliser une adresse de la forme :samp:`r'\\\\\\\\{ServerName}\\\\pipe\\\\{PipeName}'`." +"Une adresse ``'AF_PIPE'`` est une chaîne de caractères de la forme :samp:" +"`r'\\\\\\\\.\\\\pipe\\\\{PipeName}'`. Pour utiliser :func:`Client` pour se " +"connecter à un tube nommé sur une machine distante appelée *ServerName*, il " +"faut utiliser une adresse de la forme :samp:`r'\\\\\\\\{ServerName}\\\\pipe\\" +"\\{PipeName}'`." #: library/multiprocessing.rst:2576 msgid "" -"Note that any string beginning with two backslashes is assumed by default to be an ``'AF_PIPE'`` address rather " -"than an ``'AF_UNIX'`` address." +"Note that any string beginning with two backslashes is assumed by default to " +"be an ``'AF_PIPE'`` address rather than an ``'AF_UNIX'`` address." msgstr "" -"Notez que toute chaîne commençant par deux antislashs est considérée par défaut comme l'adresse d'un " -"``'AF_PIPE'`` plutôt qu'une adresse ``'AF_UNIX'``." +"Notez que toute chaîne commençant par deux antislashs est considérée par " +"défaut comme l'adresse d'un ``'AF_PIPE'`` plutôt qu'une adresse " +"``'AF_UNIX'``." #: library/multiprocessing.rst:2583 msgid "Authentication keys" @@ -3117,42 +3853,55 @@ msgstr "Clés d'authentification" #: library/multiprocessing.rst:2585 msgid "" -"When one uses :meth:`Connection.recv `, the data received is automatically unpickled. " -"Unfortunately unpickling data from an untrusted source is a security risk. Therefore :class:`Listener` and :func:" -"`Client` use the :mod:`hmac` module to provide digest authentication." +"When one uses :meth:`Connection.recv `, the data received " +"is automatically unpickled. Unfortunately unpickling data from an untrusted " +"source is a security risk. Therefore :class:`Listener` and :func:`Client` " +"use the :mod:`hmac` module to provide digest authentication." msgstr "" -"Quand :meth:`Connection.recv ` est utilisée, les données reçues sont automatiquement " -"désérialisées par *pickle*. Malheureusement désérialiser des données depuis une source non sûre constitue un " -"risque de sécurité. Par conséquent :class:`Listener` et :func:`Client` utilisent le module :mod:`hmac` pour " -"fournir une authentification par condensat." +"Quand :meth:`Connection.recv ` est utilisée, les données " +"reçues sont automatiquement désérialisées par *pickle*. Malheureusement " +"désérialiser des données depuis une source non sûre constitue un risque de " +"sécurité. Par conséquent :class:`Listener` et :func:`Client` utilisent le " +"module :mod:`hmac` pour fournir une authentification par condensat." #: library/multiprocessing.rst:2591 msgid "" -"An authentication key is a byte string which can be thought of as a password: once a connection is established " -"both ends will demand proof that the other knows the authentication key. (Demonstrating that both ends are using " -"the same key does **not** involve sending the key over the connection.)" +"An authentication key is a byte string which can be thought of as a " +"password: once a connection is established both ends will demand proof that " +"the other knows the authentication key. (Demonstrating that both ends are " +"using the same key does **not** involve sending the key over the connection.)" msgstr "" -"Une clé d'authentification est une chaîne d'octets qui peut être vue comme un mot de passe : quand une connexion " -"est établie, les deux interlocuteurs vont demander à l'autre une preuve qu'il connaît la clé d'authentification. " -"(Démontrer que les deux utilisent la même clé n'implique **pas** d'échanger la clé sur la connexion.)" +"Une clé d'authentification est une chaîne d'octets qui peut être vue comme " +"un mot de passe : quand une connexion est établie, les deux interlocuteurs " +"vont demander à l'autre une preuve qu'il connaît la clé d'authentification. " +"(Démontrer que les deux utilisent la même clé n'implique **pas** d'échanger " +"la clé sur la connexion.)" #: library/multiprocessing.rst:2597 msgid "" -"If authentication is requested but no authentication key is specified then the return value of " -"``current_process().authkey`` is used (see :class:`~multiprocessing.Process`). This value will be automatically " -"inherited by any :class:`~multiprocessing.Process` object that the current process creates. This means that (by " -"default) all processes of a multi-process program will share a single authentication key which can be used when " +"If authentication is requested but no authentication key is specified then " +"the return value of ``current_process().authkey`` is used (see :class:" +"`~multiprocessing.Process`). This value will be automatically inherited by " +"any :class:`~multiprocessing.Process` object that the current process " +"creates. This means that (by default) all processes of a multi-process " +"program will share a single authentication key which can be used when " "setting up connections between themselves." msgstr "" -"Si l'authentification est requise et qu'aucune clé n'est spécifiée alors la valeur de retour de " -"``current_process().authkey`` est utilisée (voir :class:`~multiprocessing.Process`). Celle valeur est " -"automatiquement héritée par tout objet :class:`~multiprocessing.Process` créé par le processus courant. Cela " -"signifie que (par défaut) tous les processus d'un programme multi-processus partageront une clé " -"d'authentification unique qui peut être utilisée pour mettre en place des connexions entre-eux." +"Si l'authentification est requise et qu'aucune clé n'est spécifiée alors la " +"valeur de retour de ``current_process().authkey`` est utilisée (voir :class:" +"`~multiprocessing.Process`). Celle valeur est automatiquement héritée par " +"tout objet :class:`~multiprocessing.Process` créé par le processus courant. " +"Cela signifie que (par défaut) tous les processus d'un programme multi-" +"processus partageront une clé d'authentification unique qui peut être " +"utilisée pour mettre en place des connexions entre-eux." #: library/multiprocessing.rst:2605 -msgid "Suitable authentication keys can also be generated by using :func:`os.urandom`." -msgstr "Des clés d'authentification adaptées peuvent aussi être générées par :func:`os.urandom`." +msgid "" +"Suitable authentication keys can also be generated by using :func:`os." +"urandom`." +msgstr "" +"Des clés d'authentification adaptées peuvent aussi être générées par :func:" +"`os.urandom`." #: library/multiprocessing.rst:2609 msgid "Logging" @@ -3160,51 +3909,66 @@ msgstr "Journalisation" #: library/multiprocessing.rst:2611 msgid "" -"Some support for logging is available. Note, however, that the :mod:`logging` package does not use process " -"shared locks so it is possible (depending on the handler type) for messages from different processes to get mixed " -"up." +"Some support for logging is available. Note, however, that the :mod:" +"`logging` package does not use process shared locks so it is possible " +"(depending on the handler type) for messages from different processes to get " +"mixed up." msgstr "" -"Un certain support de la journalisation est disponible. Notez cependant que le le paquet :mod:`logging` n'utilise " -"pas de verrous partagés entre les processus et il est donc possible (dépendant du type de gestionnaire) que les " -"messages de différents processus soient mélangés." +"Un certain support de la journalisation est disponible. Notez cependant que " +"le le paquet :mod:`logging` n'utilise pas de verrous partagés entre les " +"processus et il est donc possible (dépendant du type de gestionnaire) que " +"les messages de différents processus soient mélangés." #: library/multiprocessing.rst:2618 -msgid "Returns the logger used by :mod:`multiprocessing`. If necessary, a new one will be created." -msgstr "Renvoie le journaliseur utilisé par :mod:`multiprocessing`. Si nécessaire, un nouveau sera créé." +msgid "" +"Returns the logger used by :mod:`multiprocessing`. If necessary, a new one " +"will be created." +msgstr "" +"Renvoie le journaliseur utilisé par :mod:`multiprocessing`. Si nécessaire, " +"un nouveau sera créé." #: library/multiprocessing.rst:2621 msgid "" -"When first created the logger has level :data:`logging.NOTSET` and no default handler. Messages sent to this " -"logger will not by default propagate to the root logger." +"When first created the logger has level :data:`logging.NOTSET` and no " +"default handler. Messages sent to this logger will not by default propagate " +"to the root logger." msgstr "" -"À sa première création le journaliseur a pour niveau :data:`logging.NOTSET` et pas de gestionnaire par défaut. " -"Les messages envoyés à ce journaliseur ne seront pas propagés par défaut au journaliseur principal." +"À sa première création le journaliseur a pour niveau :data:`logging.NOTSET` " +"et pas de gestionnaire par défaut. Les messages envoyés à ce journaliseur ne " +"seront pas propagés par défaut au journaliseur principal." #: library/multiprocessing.rst:2625 msgid "" -"Note that on Windows child processes will only inherit the level of the parent process's logger -- any other " -"customization of the logger will not be inherited." +"Note that on Windows child processes will only inherit the level of the " +"parent process's logger -- any other customization of the logger will not be " +"inherited." msgstr "" -"Notez que sous Windows les processus fils n'hériteront que du niveau du journaliseur du processus parent – toute " -"autre personnalisation du journaliseur ne sera pas héritée." +"Notez que sous Windows les processus fils n'hériteront que du niveau du " +"journaliseur du processus parent – toute autre personnalisation du " +"journaliseur ne sera pas héritée." #: library/multiprocessing.rst:2632 msgid "" -"This function performs a call to :func:`get_logger` but in addition to returning the logger created by " -"get_logger, it adds a handler which sends output to :data:`sys.stderr` using format ``'[%(levelname)s/" -"%(processName)s] %(message)s'``." +"This function performs a call to :func:`get_logger` but in addition to " +"returning the logger created by get_logger, it adds a handler which sends " +"output to :data:`sys.stderr` using format ``'[%(levelname)s/%(processName)s] " +"%(message)s'``." msgstr "" -"Cette fonction effectue un appel à :func:`get_logger` mais en plus de renvoyer le journaliseur créé par " -"*get_logger*, elle ajoute un gestionnaire qui envoie la sortie sur :data:`sys.stderr` en utilisant le format " +"Cette fonction effectue un appel à :func:`get_logger` mais en plus de " +"renvoyer le journaliseur créé par *get_logger*, elle ajoute un gestionnaire " +"qui envoie la sortie sur :data:`sys.stderr` en utilisant le format " "``'[%(levelname)s/%(processName)s] %(message)s'``." #: library/multiprocessing.rst:2637 msgid "Below is an example session with logging turned on::" -msgstr "L'exemple ci-dessous présente une session avec la journalisation activée ::" +msgstr "" +"L'exemple ci-dessous présente une session avec la journalisation activée ::" #: library/multiprocessing.rst:2652 msgid "For a full table of logging levels, see the :mod:`logging` module." -msgstr "Pour un tableau complet des niveaux de journalisation, voir le module :mod:`logging`." +msgstr "" +"Pour un tableau complet des niveaux de journalisation, voir le module :mod:" +"`logging`." #: library/multiprocessing.rst:2656 msgid "The :mod:`multiprocessing.dummy` module" @@ -3212,76 +3976,97 @@ msgstr "Le module :mod:`multiprocessing.dummy`" #: library/multiprocessing.rst:2661 msgid "" -":mod:`multiprocessing.dummy` replicates the API of :mod:`multiprocessing` but is no more than a wrapper around " -"the :mod:`threading` module." +":mod:`multiprocessing.dummy` replicates the API of :mod:`multiprocessing` " +"but is no more than a wrapper around the :mod:`threading` module." msgstr "" -":mod:`multiprocessing.dummy` réplique toute l'API de :mod:`multiprocessing` mais n'est rien de plus qu'une " -"interface autour du module :mod:`threading`." +":mod:`multiprocessing.dummy` réplique toute l'API de :mod:`multiprocessing` " +"mais n'est rien de plus qu'une interface autour du module :mod:`threading`." #: library/multiprocessing.rst:2666 msgid "" -"In particular, the ``Pool`` function provided by :mod:`multiprocessing.dummy` returns an instance of :class:" -"`ThreadPool`, which is a subclass of :class:`Pool` that supports all the same method calls but uses a pool of " +"In particular, the ``Pool`` function provided by :mod:`multiprocessing." +"dummy` returns an instance of :class:`ThreadPool`, which is a subclass of :" +"class:`Pool` that supports all the same method calls but uses a pool of " "worker threads rather than worker processes." msgstr "" -"En particulier, la fonction ``Pool`` du module :mod:`multiprocessing.dummy` renvoie une instance de :class:" -"`ThreadPool`, qui est une sous-classe de :class:`Pool`. Elle a la même interface, mais elle utilise un pool de " -"fils d'exécution plutôt qu'un pool de processus." +"En particulier, la fonction ``Pool`` du module :mod:`multiprocessing.dummy` " +"renvoie une instance de :class:`ThreadPool`, qui est une sous-classe de :" +"class:`Pool`. Elle a la même interface, mais elle utilise un pool de fils " +"d'exécution plutôt qu'un pool de processus." #: library/multiprocessing.rst:2674 msgid "" -"A thread pool object which controls a pool of worker threads to which jobs can be submitted. :class:`ThreadPool` " -"instances are fully interface compatible with :class:`Pool` instances, and their resources must also be properly " -"managed, either by using the pool as a context manager or by calling :meth:`~multiprocessing.pool.Pool.close` " -"and :meth:`~multiprocessing.pool.Pool.terminate` manually." +"A thread pool object which controls a pool of worker threads to which jobs " +"can be submitted. :class:`ThreadPool` instances are fully interface " +"compatible with :class:`Pool` instances, and their resources must also be " +"properly managed, either by using the pool as a context manager or by " +"calling :meth:`~multiprocessing.pool.Pool.close` and :meth:`~multiprocessing." +"pool.Pool.terminate` manually." msgstr "" -"Un objet qui contrôle un pool de fils d'exécution auquel des tâches peuvent être envoyées. L'interface des " -"instances de :class:`ThreadPool` est entièrement compatible avec celle des instances de :class:`Pool`, et leur " -"ressources doivent être aussi correctement gérées, soit en utilisant le pool avec un contexte, soit ou en " -"appelant explicitement :meth:`~multiprocessing.pool.Pool.close` et :meth:`~multiprocessing.pool.Pool.terminate`." +"Un objet qui contrôle un pool de fils d'exécution auquel des tâches peuvent " +"être envoyées. L'interface des instances de :class:`ThreadPool` est " +"entièrement compatible avec celle des instances de :class:`Pool`, et leur " +"ressources doivent être aussi correctement gérées, soit en utilisant le pool " +"avec un contexte, soit ou en appelant explicitement :meth:`~multiprocessing." +"pool.Pool.close` et :meth:`~multiprocessing.pool.Pool.terminate`." #: library/multiprocessing.rst:2681 msgid "" -"*processes* is the number of worker threads to use. If *processes* is ``None`` then the number returned by :func:" -"`os.cpu_count` is used." +"*processes* is the number of worker threads to use. If *processes* is " +"``None`` then the number returned by :func:`os.cpu_count` is used." msgstr "" -"*processes* est le nombre de fils d'exécution à utiliser. Si *processes* est ``None``, le nombre renvoyé par :" -"func:`os.cpu_count` est utilisé." +"*processes* est le nombre de fils d'exécution à utiliser. Si *processes* est " +"``None``, le nombre renvoyé par :func:`os.cpu_count` est utilisé." #: library/multiprocessing.rst:2687 -msgid "Unlike :class:`Pool`, *maxtasksperchild* and *context* cannot be provided." -msgstr "À la différence de :class:`Pool`, *maxtasksperchild* et *context* ne peuvent pas être passés en arguments." +msgid "" +"Unlike :class:`Pool`, *maxtasksperchild* and *context* cannot be provided." +msgstr "" +"À la différence de :class:`Pool`, *maxtasksperchild* et *context* ne peuvent " +"pas être passés en arguments." #: library/multiprocessing.rst:2691 msgid "" -"A :class:`ThreadPool` shares the same interface as :class:`Pool`, which is designed around a pool of processes " -"and predates the introduction of the :class:`concurrent.futures` module. As such, it inherits some operations " -"that don't make sense for a pool backed by threads, and it has its own type for representing the status of " -"asynchronous jobs, :class:`AsyncResult`, that is not understood by any other libraries." -msgstr "" -"La classe :class:`ThreadPool` a la même interface que la classe :class:`Pool`, dont l'implémentation repose sur " -"un pool de processus, et a été introduite avant le module :class:`concurrent.futures`. Par conséquent elle " -"implémente des opérations qui n'ont pas vraiment de sens pour un pool implémenté avec des fil d'exécution et " -"possède son propre type pour représenter le statut de tâches asynchrones, :class:`AsyncResult`, qui n'est pas " -"géré par les autres modules." +"A :class:`ThreadPool` shares the same interface as :class:`Pool`, which is " +"designed around a pool of processes and predates the introduction of the :" +"class:`concurrent.futures` module. As such, it inherits some operations " +"that don't make sense for a pool backed by threads, and it has its own type " +"for representing the status of asynchronous jobs, :class:`AsyncResult`, that " +"is not understood by any other libraries." +msgstr "" +"La classe :class:`ThreadPool` a la même interface que la classe :class:" +"`Pool`, dont l'implémentation repose sur un pool de processus, et a été " +"introduite avant le module :class:`concurrent.futures`. Par conséquent elle " +"implémente des opérations qui n'ont pas vraiment de sens pour un pool " +"implémenté avec des fil d'exécution et possède son propre type pour " +"représenter le statut de tâches asynchrones, :class:`AsyncResult`, qui n'est " +"pas géré par les autres modules." #: library/multiprocessing.rst:2698 msgid "" -"Users should generally prefer to use :class:`concurrent.futures.ThreadPoolExecutor`, which has a simpler " -"interface that was designed around threads from the start, and which returns :class:`concurrent.futures.Future` " -"instances that are compatible with many other libraries, including :mod:`asyncio`." +"Users should generally prefer to use :class:`concurrent.futures." +"ThreadPoolExecutor`, which has a simpler interface that was designed around " +"threads from the start, and which returns :class:`concurrent.futures.Future` " +"instances that are compatible with many other libraries, including :mod:" +"`asyncio`." msgstr "" -"Il est souvent plus judicieux d'utiliser :class:`concurrent.futures.ThreadPoolExecutor` qui a une interface plus " -"simple, qui a été pensée dès l'origine pour les fils d'exécution et qui renvoie des instances de :class:" -"`concurrent.futures.Future` qui sont compatibles avec de nombreux modules, et en particulier avec :mod:`asyncio`." +"Il est souvent plus judicieux d'utiliser :class:`concurrent.futures." +"ThreadPoolExecutor` qui a une interface plus simple, qui a été pensée dès " +"l'origine pour les fils d'exécution et qui renvoie des instances de :class:" +"`concurrent.futures.Future` qui sont compatibles avec de nombreux modules, " +"et en particulier avec :mod:`asyncio`." #: library/multiprocessing.rst:2708 msgid "Programming guidelines" msgstr "Lignes directrices de programmation" #: library/multiprocessing.rst:2710 -msgid "There are certain guidelines and idioms which should be adhered to when using :mod:`multiprocessing`." -msgstr "Il y a certaines lignes directrices et idiomes à respecter pour utiliser :mod:`multiprocessing`." +msgid "" +"There are certain guidelines and idioms which should be adhered to when " +"using :mod:`multiprocessing`." +msgstr "" +"Il y a certaines lignes directrices et idiomes à respecter pour utiliser :" +"mod:`multiprocessing`." #: library/multiprocessing.rst:2715 msgid "All start methods" @@ -3296,16 +4081,22 @@ msgid "Avoid shared state" msgstr "Éviter les états partagés" #: library/multiprocessing.rst:2721 -msgid "As far as possible one should try to avoid shifting large amounts of data between processes." -msgstr "Autant que possible, il faut éviter de transférer de gros volumes de données entre les processus." +msgid "" +"As far as possible one should try to avoid shifting large amounts of data " +"between processes." +msgstr "" +"Autant que possible, il faut éviter de transférer de gros volumes de données " +"entre les processus." #: library/multiprocessing.rst:2724 msgid "" -"It is probably best to stick to using queues or pipes for communication between processes rather than using the " -"lower level synchronization primitives." +"It is probably best to stick to using queues or pipes for communication " +"between processes rather than using the lower level synchronization " +"primitives." msgstr "" -"Il est souvent plus judicieux de se borner à utiliser des files et des tubes pour gérer la communication entre " -"processus plutôt que d'utiliser des primitives de synchronisation plus bas-niveau." +"Il est souvent plus judicieux de se borner à utiliser des files et des tubes " +"pour gérer la communication entre processus plutôt que d'utiliser des " +"primitives de synchronisation plus bas-niveau." #: library/multiprocessing.rst:2728 msgid "Picklability" @@ -3313,21 +4104,28 @@ msgstr "Sérialisation" #: library/multiprocessing.rst:2730 msgid "Ensure that the arguments to the methods of proxies are picklable." -msgstr "Assurez-vous que les arguments passés aux méthodes des mandataires soient sérialisables (*pickables*)." +msgstr "" +"Assurez-vous que les arguments passés aux méthodes des mandataires soient " +"sérialisables (*pickables*)." #: library/multiprocessing.rst:2732 msgid "Thread safety of proxies" msgstr "Sûreté des mandataires à travers les fils d'exécution" #: library/multiprocessing.rst:2734 -msgid "Do not use a proxy object from more than one thread unless you protect it with a lock." +msgid "" +"Do not use a proxy object from more than one thread unless you protect it " +"with a lock." msgstr "" -"N'utilisez pas d'objet mandataire depuis plus d'un fil d'exécution à moins que vous ne le protégiez avec un " -"verrou." +"N'utilisez pas d'objet mandataire depuis plus d'un fil d'exécution à moins " +"que vous ne le protégiez avec un verrou." #: library/multiprocessing.rst:2737 -msgid "(There is never a problem with different processes using the *same* proxy.)" -msgstr "Il n'y a jamais de problème à avoir plusieurs processus qui utilisent un *même* mandataire." +msgid "" +"(There is never a problem with different processes using the *same* proxy.)" +msgstr "" +"Il n'y a jamais de problème à avoir plusieurs processus qui utilisent un " +"*même* mandataire." #: library/multiprocessing.rst:2739 msgid "Joining zombie processes" @@ -3335,18 +4133,22 @@ msgstr "Attendre les processus zombies" #: library/multiprocessing.rst:2741 msgid "" -"On Unix when a process finishes but has not been joined it becomes a zombie. There should never be very many " -"because each time a new process starts (or :func:`~multiprocessing.active_children` is called) all completed " -"processes which have not yet been joined will be joined. Also calling a finished process's :meth:`Process." -"is_alive ` will join the process. Even so it is probably good practice to " -"explicitly join all the processes that you start." -msgstr "" -"Sous Unix quand un processus se termine mais n'est pas attendu, il devient un zombie. Il ne devrait jamais y en " -"avoir beaucoup parce que chaque fois qu'un nouveau processus démarre (ou que :func:`~multiprocessing." -"active_children` est appelée) tous les processus complétés qui n'ont pas été attendus le sont alors. Appeler la " -"méthode :meth:`Process.is_alive ` d'un processus terminé attend aussi le " -"processus. Toutefois, il est, en règle générale, conseillé d'attendre explicitement tous les processus que vous " -"démarrez." +"On Unix when a process finishes but has not been joined it becomes a zombie. " +"There should never be very many because each time a new process starts (or :" +"func:`~multiprocessing.active_children` is called) all completed processes " +"which have not yet been joined will be joined. Also calling a finished " +"process's :meth:`Process.is_alive ` will " +"join the process. Even so it is probably good practice to explicitly join " +"all the processes that you start." +msgstr "" +"Sous Unix quand un processus se termine mais n'est pas attendu, il devient " +"un zombie. Il ne devrait jamais y en avoir beaucoup parce que chaque fois " +"qu'un nouveau processus démarre (ou que :func:`~multiprocessing." +"active_children` est appelée) tous les processus complétés qui n'ont pas été " +"attendus le sont alors. Appeler la méthode :meth:`Process.is_alive " +"` d'un processus terminé attend aussi le " +"processus. Toutefois, il est, en règle générale, conseillé d'attendre " +"explicitement tous les processus que vous démarrez." #: library/multiprocessing.rst:2749 msgid "Better to inherit than pickle/unpickle" @@ -3354,16 +4156,20 @@ msgstr "Mieux vaut hériter que sérialiser - désérialiser" #: library/multiprocessing.rst:2751 msgid "" -"When using the *spawn* or *forkserver* start methods many types from :mod:`multiprocessing` need to be picklable " -"so that child processes can use them. However, one should generally avoid sending shared objects to other " -"processes using pipes or queues. Instead you should arrange the program so that a process which needs access to a " -"shared resource created elsewhere can inherit it from an ancestor process." -msgstr "" -"Quand vous utilisez les méthodes de démarrage *spawn* ou *forkserver*, de nombreux types de :mod:" -"`multiprocessing` nécessitent d'être sérialisés pour que les processus enfants puissent les utiliser. Cependant, " -"il faut généralement éviter d'envoyer des objets partagés aux autres processus en utilisant des tubes ou des " -"files. Vous devez plutôt vous arranger pour qu'un processus qui nécessite l'accès à une ressource partagée créée " -"autre part qu'il en hérite depuis un de ses processus ancêtres." +"When using the *spawn* or *forkserver* start methods many types from :mod:" +"`multiprocessing` need to be picklable so that child processes can use " +"them. However, one should generally avoid sending shared objects to other " +"processes using pipes or queues. Instead you should arrange the program so " +"that a process which needs access to a shared resource created elsewhere can " +"inherit it from an ancestor process." +msgstr "" +"Quand vous utilisez les méthodes de démarrage *spawn* ou *forkserver*, de " +"nombreux types de :mod:`multiprocessing` nécessitent d'être sérialisés pour " +"que les processus enfants puissent les utiliser. Cependant, il faut " +"généralement éviter d'envoyer des objets partagés aux autres processus en " +"utilisant des tubes ou des files. Vous devez plutôt vous arranger pour qu'un " +"processus qui nécessite l'accès à une ressource partagée créée autre part " +"qu'il en hérite depuis un de ses processus ancêtres." #: library/multiprocessing.rst:2759 msgid "Avoid terminating processes" @@ -3371,21 +4177,25 @@ msgstr "Éviter de terminer les processus" #: library/multiprocessing.rst:2761 msgid "" -"Using the :meth:`Process.terminate ` method to stop a process is liable to " -"cause any shared resources (such as locks, semaphores, pipes and queues) currently being used by the process to " +"Using the :meth:`Process.terminate ` " +"method to stop a process is liable to cause any shared resources (such as " +"locks, semaphores, pipes and queues) currently being used by the process to " "become broken or unavailable to other processes." msgstr "" -"Utiliser la méthode :meth:`Process.terminate ` pour stopper un processus " -"risque de casser ou de rendre indisponible aux autres processus des ressources partagées (comme des verrous, " -"sémaphores, tubes et files) actuellement utilisées par le processus." +"Utiliser la méthode :meth:`Process.terminate ` pour stopper un processus risque de casser ou de rendre " +"indisponible aux autres processus des ressources partagées (comme des " +"verrous, sémaphores, tubes et files) actuellement utilisées par le processus." #: library/multiprocessing.rst:2767 msgid "" -"Therefore it is probably best to only consider using :meth:`Process.terminate ` on processes which never use any shared resources." +"Therefore it is probably best to only consider using :meth:`Process." +"terminate ` on processes which never use " +"any shared resources." msgstr "" -"Il est donc préférable de n'utiliser :meth:`Process.terminate ` que sur les " -"processus qui n'utilisent jamais de ressources partagées." +"Il est donc préférable de n'utiliser :meth:`Process.terminate " +"` que sur les processus qui n'utilisent " +"jamais de ressources partagées." #: library/multiprocessing.rst:2771 msgid "Joining processes that use queues" @@ -3393,34 +4203,45 @@ msgstr "Attendre les processus qui utilisent des files" #: library/multiprocessing.rst:2773 msgid "" -"Bear in mind that a process that has put items in a queue will wait before terminating until all the buffered " -"items are fed by the \"feeder\" thread to the underlying pipe. (The child process can call the :meth:`Queue." -"cancel_join_thread ` method of the queue to avoid this behaviour.)" +"Bear in mind that a process that has put items in a queue will wait before " +"terminating until all the buffered items are fed by the \"feeder\" thread to " +"the underlying pipe. (The child process can call the :meth:`Queue." +"cancel_join_thread ` method of the " +"queue to avoid this behaviour.)" msgstr "" -"Gardez à l'esprit qu'un processus qui a placé des éléments dans une file attend que tous les éléments mis en " -"tampon soient consommés par le fil d'exécution « chargeur » du tube sous-jacent avant de se terminer (le " -"processus enfant peut appeler la méthode :meth:`Queue.cancel_join_thread ` de la queue pour éviter ce comportement)." +"Gardez à l'esprit qu'un processus qui a placé des éléments dans une file " +"attend que tous les éléments mis en tampon soient consommés par le fil " +"d'exécution « chargeur » du tube sous-jacent avant de se terminer (le " +"processus enfant peut appeler la méthode :meth:`Queue.cancel_join_thread " +"` de la queue pour éviter ce " +"comportement)." #: library/multiprocessing.rst:2779 msgid "" -"This means that whenever you use a queue you need to make sure that all items which have been put on the queue " -"will eventually be removed before the process is joined. Otherwise you cannot be sure that processes which have " -"put items on the queue will terminate. Remember also that non-daemonic processes will be joined automatically." +"This means that whenever you use a queue you need to make sure that all " +"items which have been put on the queue will eventually be removed before the " +"process is joined. Otherwise you cannot be sure that processes which have " +"put items on the queue will terminate. Remember also that non-daemonic " +"processes will be joined automatically." msgstr "" -"Cela signifie que chaque fois que vous utilisez une file, vous devez vous assurer que tous les éléments qui y ont " -"été placés ont été effectivement supprimés avant que le processus ne soit attendu. Autrement vous ne pouvez pas " -"être sûr que les processus qui ont placé des éléments dans la file se termineront. Souvenez-vous aussi que tous " -"les processus non *daemons* sont attendus automatiquement." +"Cela signifie que chaque fois que vous utilisez une file, vous devez vous " +"assurer que tous les éléments qui y ont été placés ont été effectivement " +"supprimés avant que le processus ne soit attendu. Autrement vous ne pouvez " +"pas être sûr que les processus qui ont placé des éléments dans la file se " +"termineront. Souvenez-vous aussi que tous les processus non *daemons* sont " +"attendus automatiquement." #: library/multiprocessing.rst:2785 msgid "An example which will deadlock is the following::" msgstr "L'exemple suivant provoquera un interblocage ::" #: library/multiprocessing.rst:2799 -msgid "A fix here would be to swap the last two lines (or simply remove the ``p.join()`` line)." +msgid "" +"A fix here would be to swap the last two lines (or simply remove the ``p." +"join()`` line)." msgstr "" -"Une solution ici serait d'intervertir les deux dernières lignes (ou simplement supprimer la ligne ``p.join()``)." +"Une solution ici serait d'intervertir les deux dernières lignes (ou " +"simplement supprimer la ligne ``p.join()``)." #: library/multiprocessing.rst:2802 msgid "Explicitly pass resources to child processes" @@ -3428,24 +4249,30 @@ msgstr "Passer explicitement les ressources aux processus fils" #: library/multiprocessing.rst:2804 msgid "" -"On Unix using the *fork* start method, a child process can make use of a shared resource created in a parent " -"process using a global resource. However, it is better to pass the object as an argument to the constructor for " -"the child process." +"On Unix using the *fork* start method, a child process can make use of a " +"shared resource created in a parent process using a global resource. " +"However, it is better to pass the object as an argument to the constructor " +"for the child process." msgstr "" -"Sous Unix en utilisant la méthode de démarrage *fork*, un processus fils peut utiliser une ressource partagée " -"créée par un processus parent en utilisant une ressource globale. Cependant, il est préférable de passer l'objet " -"en argument au constructeur du processus fils." +"Sous Unix en utilisant la méthode de démarrage *fork*, un processus fils " +"peut utiliser une ressource partagée créée par un processus parent en " +"utilisant une ressource globale. Cependant, il est préférable de passer " +"l'objet en argument au constructeur du processus fils." #: library/multiprocessing.rst:2809 msgid "" -"Apart from making the code (potentially) compatible with Windows and the other start methods this also ensures " -"that as long as the child process is still alive the object will not be garbage collected in the parent process. " -"This might be important if some resource is freed when the object is garbage collected in the parent process." +"Apart from making the code (potentially) compatible with Windows and the " +"other start methods this also ensures that as long as the child process is " +"still alive the object will not be garbage collected in the parent process. " +"This might be important if some resource is freed when the object is garbage " +"collected in the parent process." msgstr "" -"En plus de rendre le code (potentiellement) compatible avec Windows et les autres méthodes de démarrage, cela " -"assure aussi que tant que le processus fils est en vie, l'objet ne sera pas collecté par le ramasse-miettes du " -"processus parent. Cela peut être important si certaines ressources sont libérées quand l'objet est collecté par " -"le ramasse-miettes du processus parent." +"En plus de rendre le code (potentiellement) compatible avec Windows et les " +"autres méthodes de démarrage, cela assure aussi que tant que le processus " +"fils est en vie, l'objet ne sera pas collecté par le ramasse-miettes du " +"processus parent. Cela peut être important si certaines ressources sont " +"libérées quand l'objet est collecté par le ramasse-miettes du processus " +"parent." #: library/multiprocessing.rst:2816 msgid "So for instance ::" @@ -3457,7 +4284,8 @@ msgstr "devrait être réécrit comme ::" #: library/multiprocessing.rst:2840 msgid "Beware of replacing :data:`sys.stdin` with a \"file like object\"" -msgstr "Faire attention à remplacer :data:`sys.stdin` par un objet simili-fichier" +msgstr "" +"Faire attention à remplacer :data:`sys.stdin` par un objet simili-fichier" #: library/multiprocessing.rst:2842 msgid ":mod:`multiprocessing` originally unconditionally called::" @@ -3465,45 +4293,56 @@ msgstr "À l'origine, :mod:`multiprocessing` appelait inconditionnellement ::" #: library/multiprocessing.rst:2846 msgid "" -"in the :meth:`multiprocessing.Process._bootstrap` method --- this resulted in issues with processes-in-processes. " -"This has been changed to::" +"in the :meth:`multiprocessing.Process._bootstrap` method --- this resulted " +"in issues with processes-in-processes. This has been changed to::" msgstr "" -"dans la méthode :meth:`multiprocessing.Process._bootstrap` — cela provoquait des problèmes avec les processus " -"imbriqués. Cela peut être changé en ::" +"dans la méthode :meth:`multiprocessing.Process._bootstrap` — cela provoquait " +"des problèmes avec les processus imbriqués. Cela peut être changé en ::" #: library/multiprocessing.rst:2852 msgid "" -"Which solves the fundamental issue of processes colliding with each other resulting in a bad file descriptor " -"error, but introduces a potential danger to applications which replace :func:`sys.stdin` with a \"file-like object" -"\" with output buffering. This danger is that if multiple processes call :meth:`~io.IOBase.close()` on this file-" -"like object, it could result in the same data being flushed to the object multiple times, resulting in corruption." -msgstr "" -"Qui résout le problème fondamental des collisions entre processus provoquant des erreurs de mauvais descripteurs " -"de fichiers, mais introduit un potentiel danger pour les applications qui remplacent :func:`sys.stdin` avec un " -"objet simili-fichier ayant une sortie mise en tampon. Ce danger est que si plusieurs processus appellent :meth:" -"`~io.IOBase.close()` sur cet objet, cela peut amener les données à être transmises à l'objet à plusieurs " -"reprises, résultant en une corruption." +"Which solves the fundamental issue of processes colliding with each other " +"resulting in a bad file descriptor error, but introduces a potential danger " +"to applications which replace :func:`sys.stdin` with a \"file-like object\" " +"with output buffering. This danger is that if multiple processes call :meth:" +"`~io.IOBase.close()` on this file-like object, it could result in the same " +"data being flushed to the object multiple times, resulting in corruption." +msgstr "" +"Qui résout le problème fondamental des collisions entre processus provoquant " +"des erreurs de mauvais descripteurs de fichiers, mais introduit un potentiel " +"danger pour les applications qui remplacent :func:`sys.stdin` avec un objet " +"simili-fichier ayant une sortie mise en tampon. Ce danger est que si " +"plusieurs processus appellent :meth:`~io.IOBase.close()` sur cet objet, cela " +"peut amener les données à être transmises à l'objet à plusieurs reprises, " +"résultant en une corruption." #: library/multiprocessing.rst:2859 msgid "" -"If you write a file-like object and implement your own caching, you can make it fork-safe by storing the pid " -"whenever you append to the cache, and discarding the cache when the pid changes. For example::" +"If you write a file-like object and implement your own caching, you can make " +"it fork-safe by storing the pid whenever you append to the cache, and " +"discarding the cache when the pid changes. For example::" msgstr "" -"Si vous écrivez un objet simili-fichier et implémentez votre propre cache, vous pouvez le rendre sûr pour les " -"*forks* en stockant le *pid* chaque fois que vous ajoutez des données au cache, et annulez le cache quand le " -"*pid* change. Par exemple ::" +"Si vous écrivez un objet simili-fichier et implémentez votre propre cache, " +"vous pouvez le rendre sûr pour les *forks* en stockant le *pid* chaque fois " +"que vous ajoutez des données au cache, et annulez le cache quand le *pid* " +"change. Par exemple ::" #: library/multiprocessing.rst:2871 -msgid "For more information, see :issue:`5155`, :issue:`5313` and :issue:`5331`" -msgstr "Pour plus d'informations, voir :issue:`5155`, :issue:`5313` et :issue:`5331`" +msgid "" +"For more information, see :issue:`5155`, :issue:`5313` and :issue:`5331`" +msgstr "" +"Pour plus d'informations, voir :issue:`5155`, :issue:`5313` et :issue:`5331`" #: library/multiprocessing.rst:2874 msgid "The *spawn* and *forkserver* start methods" msgstr "Les méthodes de démarrage *spawn* et *forkserver*" #: library/multiprocessing.rst:2876 -msgid "There are a few extra restriction which don't apply to the *fork* start method." -msgstr "Certaines restrictions ne s'appliquent pas à la méthode de démarrage *fork*." +msgid "" +"There are a few extra restriction which don't apply to the *fork* start " +"method." +msgstr "" +"Certaines restrictions ne s'appliquent pas à la méthode de démarrage *fork*." #: library/multiprocessing.rst:2879 msgid "More picklability" @@ -3511,13 +4350,16 @@ msgstr "Contraintes supplémentaires sur la sérialisation" #: library/multiprocessing.rst:2881 msgid "" -"Ensure that all arguments to :meth:`Process.__init__` are picklable. Also, if you subclass :class:" -"`~multiprocessing.Process` then make sure that instances will be picklable when the :meth:`Process.start " -"` method is called." +"Ensure that all arguments to :meth:`Process.__init__` are picklable. Also, " +"if you subclass :class:`~multiprocessing.Process` then make sure that " +"instances will be picklable when the :meth:`Process.start ` method is called." msgstr "" -"Assurez-vous que tous les argument de :meth:`Process.__init__` sont sérialisables avec *pickle*. Aussi, si vous " -"héritez de :class:`~multiprocessing.Process`, assurez-vous que toutes les instances sont sérialisables quand la " -"méthode :meth:`Process.start ` est appelée." +"Assurez-vous que tous les argument de :meth:`Process.__init__` sont " +"sérialisables avec *pickle*. Aussi, si vous héritez de :class:" +"`~multiprocessing.Process`, assurez-vous que toutes les instances sont " +"sérialisables quand la méthode :meth:`Process.start ` est appelée." #: library/multiprocessing.rst:2886 msgid "Global variables" @@ -3525,17 +4367,24 @@ msgstr "Variables globales" #: library/multiprocessing.rst:2888 msgid "" -"Bear in mind that if code run in a child process tries to access a global variable, then the value it sees (if " -"any) may not be the same as the value in the parent process at the time that :meth:`Process.start " -"` was called." +"Bear in mind that if code run in a child process tries to access a global " +"variable, then the value it sees (if any) may not be the same as the value " +"in the parent process at the time that :meth:`Process.start ` was called." msgstr "" -"Gardez en tête que si le code exécuté dans un processus fils essaie d'accéder à une variable globale, alors la " -"valeur qu'il voit (s'il y en a une) pourrait ne pas être la même que la valeur du processus parent au moment même " -"où :meth:`Process.start ` est appelée." +"Gardez en tête que si le code exécuté dans un processus fils essaie " +"d'accéder à une variable globale, alors la valeur qu'il voit (s'il y en a " +"une) pourrait ne pas être la même que la valeur du processus parent au " +"moment même où :meth:`Process.start ` est " +"appelée." #: library/multiprocessing.rst:2893 -msgid "However, global variables which are just module level constants cause no problems." -msgstr "Cependant, les variables globales qui sont juste des constantes de modules ne posent pas de problèmes." +msgid "" +"However, global variables which are just module level constants cause no " +"problems." +msgstr "" +"Cependant, les variables globales qui sont juste des constantes de modules " +"ne posent pas de problèmes." #: library/multiprocessing.rst:2896 msgid "Safe importing of main module" @@ -3543,43 +4392,53 @@ msgstr "Importation sécurisée du module principal" #: library/multiprocessing.rst:2898 msgid "" -"Make sure that the main module can be safely imported by a new Python interpreter without causing unintended side " -"effects (such a starting a new process)." +"Make sure that the main module can be safely imported by a new Python " +"interpreter without causing unintended side effects (such a starting a new " +"process)." msgstr "" -"Assurez-vous que le module principal peut être importé en toute sécurité par un nouvel interpréteur Python sans " -"causer d'effets de bord inattendus (comme le démarrage d'un nouveau processus)." +"Assurez-vous que le module principal peut être importé en toute sécurité par " +"un nouvel interpréteur Python sans causer d'effets de bord inattendus (comme " +"le démarrage d'un nouveau processus)." #: library/multiprocessing.rst:2902 msgid "" -"For example, using the *spawn* or *forkserver* start method running the following module would fail with a :exc:" -"`RuntimeError`::" +"For example, using the *spawn* or *forkserver* start method running the " +"following module would fail with a :exc:`RuntimeError`::" msgstr "" -"Par exemple, utiliser la méthode de démarrage *spawn* ou *forkserver* pour lancer le module suivant échouerait " -"avec une :exc:`RuntimeError` ::" +"Par exemple, utiliser la méthode de démarrage *spawn* ou *forkserver* pour " +"lancer le module suivant échouerait avec une :exc:`RuntimeError` ::" #: library/multiprocessing.rst:2914 msgid "" -"Instead one should protect the \"entry point\" of the program by using ``if __name__ == '__main__':`` as follows::" +"Instead one should protect the \"entry point\" of the program by using ``if " +"__name__ == '__main__':`` as follows::" msgstr "" -"Vous devriez plutôt protéger le « point d'entrée » du programme en utilisant ``if __name__ == '__main__':`` comme " -"suit ::" +"Vous devriez plutôt protéger le « point d'entrée » du programme en utilisant " +"``if __name__ == '__main__':`` comme suit ::" #: library/multiprocessing.rst:2928 -msgid "(The ``freeze_support()`` line can be omitted if the program will be run normally instead of frozen.)" +msgid "" +"(The ``freeze_support()`` line can be omitted if the program will be run " +"normally instead of frozen.)" msgstr "" -"(La ligne ``freeze_support()`` peut être omise si le programme est uniquement lancé normalement et pas figé.)" +"(La ligne ``freeze_support()`` peut être omise si le programme est " +"uniquement lancé normalement et pas figé.)" #: library/multiprocessing.rst:2931 msgid "" -"This allows the newly spawned Python interpreter to safely import the module and then run the module's ``foo()`` " -"function." +"This allows the newly spawned Python interpreter to safely import the module " +"and then run the module's ``foo()`` function." msgstr "" -"Cela permet aux interpréteurs Python fraîchement instanciés d'importer en toute sécurité le module et d'exécution " -"ensuite la fonction ``foo()``." +"Cela permet aux interpréteurs Python fraîchement instanciés d'importer en " +"toute sécurité le module et d'exécution ensuite la fonction ``foo()``." #: library/multiprocessing.rst:2934 -msgid "Similar restrictions apply if a pool or manager is created in the main module." -msgstr "Des restrictions similaires s'appliquent si un pool ou un gestionnaire est créé dans le module principal." +msgid "" +"Similar restrictions apply if a pool or manager is created in the main " +"module." +msgstr "" +"Des restrictions similaires s'appliquent si un pool ou un gestionnaire est " +"créé dans le module principal." #: library/multiprocessing.rst:2941 msgid "Examples" @@ -3587,7 +4446,9 @@ msgstr "Exemples" #: library/multiprocessing.rst:2943 msgid "Demonstration of how to create and use customized managers and proxies:" -msgstr "Démonstration de comment créer et utiliser des gestionnaires et mandataires personnalisés :" +msgstr "" +"Démonstration de comment créer et utiliser des gestionnaires et mandataires " +"personnalisés :" #: library/multiprocessing.rst:2949 msgid "Using :class:`~multiprocessing.pool.Pool`:" @@ -3595,10 +4456,11 @@ msgstr "En utilisant :class:`~multiprocessing.pool.Pool` :" #: library/multiprocessing.rst:2955 msgid "" -"An example showing how to use queues to feed tasks to a collection of worker processes and collect the results:" +"An example showing how to use queues to feed tasks to a collection of worker " +"processes and collect the results:" msgstr "" -"Un exemple montrant comment utiliser des files pour alimenter en tâches une collection de processus *workers* et " -"collecter les résultats :" +"Un exemple montrant comment utiliser des files pour alimenter en tâches une " +"collection de processus *workers* et collecter les résultats :" #~ msgid "An ``'AF_PIPE'`` address is a string of the form" #~ msgstr "Une adresse ``'AF_PIPE'`` est une chaîne de la forme" From 58b3aa962d2988aee8cd116c8610944a7f44774a Mon Sep 17 00:00:00 2001 From: Antoine Wecxsteen Date: Sat, 17 Jul 2021 16:01:24 +0200 Subject: [PATCH 04/10] revert mauvais merge du Makefile --- Makefile | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Makefile b/Makefile index b6538a9e2..d087c51f6 100644 --- a/Makefile +++ b/Makefile @@ -88,6 +88,11 @@ ensure_prerequisites: echo " git clone $(UPSTREAM) $(CPYTHON_PATH)"; \ exit 1; \ fi + @if [ -n "$$(git -C $(CPYTHON_PATH) status --porcelain)" ]; then \ + echo "Your cpython clone at $(CPYTHON_PATH) is not clean."; \ + echo "In order to avoid breaking things, please clean it first."; \ + exit 1; \ + fi @if ! (blurb help >/dev/null 2>&1 && sphinx-build --version >/dev/null 2>&1); then \ git -C $(CPYTHON_PATH) checkout $(BRANCH); \ echo "You're missing dependencies, please enable a venv and install:"; \ From b07a22acdfb9ee5e52e8e0add9ed67e6c1654cec Mon Sep 17 00:00:00 2001 From: Antoine Wecxsteen Date: Sat, 17 Jul 2021 16:16:43 +0200 Subject: [PATCH 05/10] modifs mineures --- Makefile | 5 --- library/multiprocessing.po | 77 +++++++++++++++++++------------------- 2 files changed, 39 insertions(+), 43 deletions(-) diff --git a/Makefile b/Makefile index d087c51f6..b6538a9e2 100644 --- a/Makefile +++ b/Makefile @@ -88,11 +88,6 @@ ensure_prerequisites: echo " git clone $(UPSTREAM) $(CPYTHON_PATH)"; \ exit 1; \ fi - @if [ -n "$$(git -C $(CPYTHON_PATH) status --porcelain)" ]; then \ - echo "Your cpython clone at $(CPYTHON_PATH) is not clean."; \ - echo "In order to avoid breaking things, please clean it first."; \ - exit 1; \ - fi @if ! (blurb help >/dev/null 2>&1 && sphinx-build --version >/dev/null 2>&1); then \ git -C $(CPYTHON_PATH) checkout $(BRANCH); \ echo "You're missing dependencies, please enable a venv and install:"; \ diff --git a/library/multiprocessing.po b/library/multiprocessing.po index e26450cd7..892efd24e 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -345,12 +345,12 @@ msgid "" "corruption from processes using different ends of the pipe at the same time." msgstr "" "Les deux objets de connexion renvoyés par :func:`Pipe` représentent les deux " -"bouts d'un tube. Chaque objet de connexion possède (entre autres) des " +"extrémités d'un tube. Chaque objet de connexion possède (entre autres) des " "méthodes :meth:`~Connection.send` et :meth:`~Connection.recv`. Notez que les " "données d'un tube peuvent être corrompues si deux processus (ou fils " -"d'exécution) essaient de lire ou d'écrire sur le même bout du tube en même " -"temps. Évidemment il n'y a pas de risque de corruption si les processus " -"utilisent deux bouts différents en même temps." +"d'exécution) essaient de lire ou d'écrire sur la même extrémité du tube en " +"même temps. Bien évidemment, deux processus peuvent utiliser les deux " +"extrémités différentes en même temps sans rique de corruption." #: library/multiprocessing.rst:261 msgid "Synchronization between processes" @@ -672,7 +672,7 @@ msgstr "" "Le nom initial est déterminé par le constructeur. Si aucun nom explicite " "n'est fourni au constructeur, un nom de la forme « Process-N\\ :sub:`1`:N\\ :" "sub:`2`:...:N\\ :sub:`k` » est construit, où chaque N\\ :sub:`k` est le N\\ :" -"sup:`e` enfant de son parent." +"sup:`e` fils de son parent." #: library/multiprocessing.rst:540 msgid "Return whether the process is alive." @@ -703,7 +703,7 @@ msgid "" "When a process exits, it attempts to terminate all of its daemonic child " "processes." msgstr "" -"Quand un processus se ferme, il tente de terminer tous ses processus enfants " +"Quand un processus se ferme, il tente de terminer tous ses processus fils " "*daemon*." #: library/multiprocessing.rst:555 @@ -715,8 +715,8 @@ msgid "" "(and not joined) if non-daemonic processes have exited." msgstr "" "Notez qu'un processus *daemon* n'est pas autorisé à créer des processus " -"fils. Sinon un processus *daemon* laisserait ses enfants orphelins lorsqu'il " -"se termine par la fermeture de son parent. De plus, ce **ne sont pas** des " +"fils. Sinon un processus *daemon* laisserait ses fils orphelins lorsqu'il se " +"termine par la fermeture de son parent. De plus, ce **ne sont pas** des " "*daemons* ou services Unix, ce sont des processus normaux qui seront " "terminés (et non attendus) si un processus non *daemon* se ferme." @@ -828,7 +828,7 @@ msgid "" "deadlock." msgstr "" "Si cette méthode est utilisée quand le processus associé utilise un tube ou " -"une file, alors le tube ou la filesont susceptibles d'être corrompus et " +"une file, alors le tube ou la file sont susceptibles d'être corrompus et " "peuvent devenir inutilisables par les autres processus. De façon similaire, " "si le processus a acquis un verrou, un sémaphore ou autre, alors le terminer " "est susceptible de provoquer des blocages dans les autres processus." @@ -905,8 +905,8 @@ msgid "" "communication between processes and avoids having to use any synchronization " "primitives like locks." msgstr "" -"Quand de plusieurs processus travaillent ensemble, il est souvent nécessaire " -"de les faire communiquer entre eux pour éviter d'avoir à utiliser des " +"Quand plusieurs processus travaillent ensemble, il est souvent nécessaire de " +"les faire communiquer entre eux pour éviter d'avoir à utiliser des " "primitives de synchronisation comme les verrous." #: library/multiprocessing.rst:686 @@ -1041,7 +1041,7 @@ msgstr "" "obtenir un interblocage, à moins que vous ne soyez sûr que tous les éléments " "placés dans la file ont été consommés. De même, si le processus fils n'est " "pas un *daemon* alors le processus parent pourrait bloquer à la fermeture " -"quand il tentera d'attendre tous ses enfants non *daemons*." +"quand il tentera d'attendre tous ses fils non *daemons*." #: library/multiprocessing.rst:749 msgid "" @@ -1065,7 +1065,7 @@ msgid "" "Connection` objects representing the ends of a pipe." msgstr "" "Renvoie une paire ``(conn1, conn2)`` d'objets :class:`~multiprocessing." -"connection.Connection` représentant les bouts d'un tube." +"connection.Connection` représentant les extrémités d'un tube." #: library/multiprocessing.rst:762 msgid "" @@ -1086,8 +1086,8 @@ msgid "" msgstr "" "Renvoie une file partagée entre les processus utilisant un tube et quelques " "verrous / sémaphores. Quand un processus place initialement un élément sur " -"la file, un fil d'exécution *feeder* est démarré pour transférer les objets " -"du tampon vers le tube." +"la file, un fil d'exécution *chargeur* est démarré pour transférer les " +"objets du tampon vers le tube." #: library/multiprocessing.rst:774 msgid "" @@ -1268,8 +1268,7 @@ msgstr "" "``allow_exit_without_flush()``. Cela peut provoquer des pertes de données " "placées dans la file, et il est très rare d'avoir besoin de l'utiliser. Elle " "n'est là que si vous souhaitez terminer immédiatement le processus sans " -"transférer les données du tampon, et que vous ne vous inquiétez pas de " -"perdre des données." +"transférer les données du tampon, et que vous êtes prêt à perdre des données." #: library/multiprocessing.rst:871 msgid "" @@ -1384,7 +1383,7 @@ msgstr "Divers" #: library/multiprocessing.rst:941 msgid "Return list of all live children of the current process." -msgstr "Renvoie la liste de tous les enfants vivants du processus courant." +msgstr "Renvoie la liste de tous les fils vivants du processus courant." #: library/multiprocessing.rst:943 msgid "" @@ -1609,8 +1608,8 @@ msgid "" "Send an object to the other end of the connection which should be read " "using :meth:`recv`." msgstr "" -"Envoie un objet sur l'autre bout de la connexion, qui devra être lu avec :" -"meth:`recv`." +"Envoie un objet sur l'autre extrémité de la connexion, qui devra être lu " +"avec :meth:`recv`." #: library/multiprocessing.rst:1087 msgid "" @@ -1627,9 +1626,10 @@ msgid "" "`send`. Blocks until there is something to receive. Raises :exc:`EOFError` " "if there is nothing left to receive and the other end was closed." msgstr "" -"Renvoie un objet envoyé depuis l'autre bout de la connexion en utilisant :" -"meth:`send`. Bloque jusqu'à ce que quelque chose soit reçu. Lève une :exc:" -"`EOFError` s'il n'y a plus rien à recevoir et que l'autre bout a été fermé." +"Renvoie un objet envoyé depuis l'autre extrémité de la connexion en " +"utilisant :meth:`send`. Bloque jusqu'à ce que quelque chose soit reçu. Lève " +"une :exc:`EOFError` s'il n'y a plus rien à recevoir et que l'autre extrémité " +"a été fermée." #: library/multiprocessing.rst:1099 msgid "Return the file descriptor or handle used by the connection." @@ -1695,10 +1695,10 @@ msgid "" "exc:`EOFError` if there is nothing left to receive and the other end has " "closed." msgstr "" -"Renvoie un message complet de données binaires envoyées depuis l'autre bout " -"de la connexion comme une chaîne de caractères. Bloque jusqu'à ce qu'il y " -"ait quelque chose à recevoir. Lève une :exc:`EOFError` s'il ne reste rien à " -"recevoir et que l'autre côté de la connexion a été fermé." +"Renvoie un message complet de données binaires envoyées depuis l'autre " +"extrémité de la connexion comme une chaîne de caractères. Bloque jusqu'à ce " +"qu'il y ait quelque chose à recevoir. Lève une :exc:`EOFError` s'il ne reste " +"rien à recevoir et que l'autre côté de la connexion a été fermé." #: library/multiprocessing.rst:1134 msgid "" @@ -1724,7 +1724,7 @@ msgid "" "nothing left to receive and the other end was closed." msgstr "" "Lit et stocke dans *buffer* un message complet de données binaires envoyées " -"depuis l'autre bout de la connexion et renvoie le nombre d'octets du " +"depuis l'autre extrémité de la connexion et renvoie le nombre d'octets du " "message. Bloque jusqu'à ce qu'il y ait quelque chose à recevoir. Lève une :" "exc:`EOFError` s'il ne reste rien à recevoir et que l'autre côté de la " "connexion a été fermé." @@ -2153,7 +2153,7 @@ msgid "" "inherited by child processes." msgstr "" "Il est possible de créer des objets partagés utilisant une mémoire partagée " -"pouvant être héritée par les processus enfants." +"pouvant être héritée par les processus fils." #: library/multiprocessing.rst:1406 msgid "" @@ -2536,8 +2536,8 @@ msgid "" msgstr "" "Renvoie un objet :class:`~multiprocessing.managers.SyncManager` démarré qui " "peut être utilisé pour partager des objets entre les processus. L'objet " -"gestionnaire renvoyé correspond à un processus enfant instancié et possède " -"des méthodes pour créer des objets partagés et renvoyer les mandataires " +"gestionnaire renvoyé correspond à un processus fils instancié et possède des " +"méthodes pour créer des objets partagés et renvoyer les mandataires " "correspondants." #: library/multiprocessing.rst:1645 @@ -3533,8 +3533,8 @@ msgid "" "Send a randomly generated message to the other end of the connection and " "wait for a reply." msgstr "" -"Envoie un message généré aléatoirement à l'autre bout de la connexion et " -"attend une réponse." +"Envoie un message généré aléatoirement à l'autre extrémité de la connexion " +"et attend une réponse." #: library/multiprocessing.rst:2360 msgid "" @@ -3543,8 +3543,9 @@ msgid "" "Otherwise :exc:`~multiprocessing.AuthenticationError` is raised." msgstr "" "Si la réponse correspond au condensat du message avec la clé *authkey*, " -"alors un message de bienvenue est envoyé à l'autre bout de la connexion. " -"Autrement, une :exc:`~multiprocessing.AuthenticationError` est levée." +"alors un message de bienvenue est envoyé à l'autre extrémité de la " +"connexion. Autrement, une :exc:`~multiprocessing.AuthenticationError` est " +"levée." #: library/multiprocessing.rst:2366 msgid "" @@ -3747,7 +3748,7 @@ msgid "" "read from it, or the other end has been closed." msgstr "" "Une connexion (*socket* en anglais) est prête quand il y a des données " -"disponibles en lecture dessus, ou que l'autre bout a été fermé." +"disponibles en lecture dessus, ou que l'autre extrémitée a été fermée." #: library/multiprocessing.rst:2470 msgid "" @@ -4165,7 +4166,7 @@ msgid "" msgstr "" "Quand vous utilisez les méthodes de démarrage *spawn* ou *forkserver*, de " "nombreux types de :mod:`multiprocessing` nécessitent d'être sérialisés pour " -"que les processus enfants puissent les utiliser. Cependant, il faut " +"que les processus fils puissent les utiliser. Cependant, il faut " "généralement éviter d'envoyer des objets partagés aux autres processus en " "utilisant des tubes ou des files. Vous devez plutôt vous arranger pour qu'un " "processus qui nécessite l'accès à une ressource partagée créée autre part " @@ -4212,7 +4213,7 @@ msgstr "" "Gardez à l'esprit qu'un processus qui a placé des éléments dans une file " "attend que tous les éléments mis en tampon soient consommés par le fil " "d'exécution « chargeur » du tube sous-jacent avant de se terminer (le " -"processus enfant peut appeler la méthode :meth:`Queue.cancel_join_thread " +"processus fils peut appeler la méthode :meth:`Queue.cancel_join_thread " "` de la queue pour éviter ce " "comportement)." From 70ad08fad4fb9d5e1d5f7e1420e54fa44113df6a Mon Sep 17 00:00:00 2001 From: Antoine Wecxsteen Date: Sat, 17 Jul 2021 16:17:59 +0200 Subject: [PATCH 06/10] remove Makefile --- Makefile | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/Makefile b/Makefile index b6538a9e2..d087c51f6 100644 --- a/Makefile +++ b/Makefile @@ -88,6 +88,11 @@ ensure_prerequisites: echo " git clone $(UPSTREAM) $(CPYTHON_PATH)"; \ exit 1; \ fi + @if [ -n "$$(git -C $(CPYTHON_PATH) status --porcelain)" ]; then \ + echo "Your cpython clone at $(CPYTHON_PATH) is not clean."; \ + echo "In order to avoid breaking things, please clean it first."; \ + exit 1; \ + fi @if ! (blurb help >/dev/null 2>&1 && sphinx-build --version >/dev/null 2>&1); then \ git -C $(CPYTHON_PATH) checkout $(BRANCH); \ echo "You're missing dependencies, please enable a venv and install:"; \ From 05653c7a7c598eddd83a8974bfedc8dc96a177d1 Mon Sep 17 00:00:00 2001 From: Antoine Wecxsteen Date: Sat, 17 Jul 2021 16:20:44 +0200 Subject: [PATCH 07/10] pospell --- library/multiprocessing.po | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/library/multiprocessing.po b/library/multiprocessing.po index 892efd24e..69a730a59 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -350,7 +350,7 @@ msgstr "" "données d'un tube peuvent être corrompues si deux processus (ou fils " "d'exécution) essaient de lire ou d'écrire sur la même extrémité du tube en " "même temps. Bien évidemment, deux processus peuvent utiliser les deux " -"extrémités différentes en même temps sans rique de corruption." +"extrémités différentes en même temps sans risque de corruption." #: library/multiprocessing.rst:261 msgid "Synchronization between processes" @@ -3748,7 +3748,7 @@ msgid "" "read from it, or the other end has been closed." msgstr "" "Une connexion (*socket* en anglais) est prête quand il y a des données " -"disponibles en lecture dessus, ou que l'autre extrémitée a été fermée." +"disponibles en lecture dessus, ou que l'autre extrémité a été fermée." #: library/multiprocessing.rst:2470 msgid "" From 6da1d01224c4284b3ff64dca806d39c77aa5b68f Mon Sep 17 00:00:00 2001 From: Antoine <43954001+awecx@users.noreply.github.com> Date: Mon, 19 Jul 2021 20:35:10 +0200 Subject: [PATCH 08/10] Suggestions de christopheNan. Co-authored-by: Christophe Nanteuil <35002064+christopheNan@users.noreply.github.com> --- library/multiprocessing.po | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/library/multiprocessing.po b/library/multiprocessing.po index 69a730a59..36e52eab3 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -500,7 +500,7 @@ msgid "" "Note that the methods of a pool should only ever be used by the process " "which created it." msgstr "" -"Notez que les méthodes d'une pool ne doivent être utilisées que par le " +"Notez que les méthodes d'un pool ne doivent être utilisées que par le " "processus qui l'a créée." #: library/multiprocessing.rst:432 @@ -4008,7 +4008,7 @@ msgstr "" "être envoyées. L'interface des instances de :class:`ThreadPool` est " "entièrement compatible avec celle des instances de :class:`Pool`, et leur " "ressources doivent être aussi correctement gérées, soit en utilisant le pool " -"avec un contexte, soit ou en appelant explicitement :meth:`~multiprocessing." +"avec un contexte, soit en appelant explicitement :meth:`~multiprocessing." "pool.Pool.close` et :meth:`~multiprocessing.pool.Pool.terminate`." #: library/multiprocessing.rst:2681 @@ -4039,7 +4039,7 @@ msgstr "" "`Pool`, dont l'implémentation repose sur un pool de processus, et a été " "introduite avant le module :class:`concurrent.futures`. Par conséquent elle " "implémente des opérations qui n'ont pas vraiment de sens pour un pool " -"implémenté avec des fil d'exécution et possède son propre type pour " +"implémenté avec des fils d'exécution et possède son propre type pour " "représenter le statut de tâches asynchrones, :class:`AsyncResult`, qui n'est " "pas géré par les autres modules." @@ -4055,7 +4055,7 @@ msgstr "" "ThreadPoolExecutor` qui a une interface plus simple, qui a été pensée dès " "l'origine pour les fils d'exécution et qui renvoie des instances de :class:" "`concurrent.futures.Future` qui sont compatibles avec de nombreux modules, " -"et en particulier avec :mod:`asyncio`." +"dont :mod:`asyncio`." #: library/multiprocessing.rst:2708 msgid "Programming guidelines" From fb07c91a0d280645b83fbf4a0227e26d1ab0c4c7 Mon Sep 17 00:00:00 2001 From: Antoine Wecxsteen Date: Mon, 19 Jul 2021 21:30:42 +0200 Subject: [PATCH 09/10] Remarque de christopheNan. --- library/multiprocessing.po | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/library/multiprocessing.po b/library/multiprocessing.po index 36e52eab3..3b0d5d15e 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -92,8 +92,8 @@ msgstr "" msgid "" "To show the individual process IDs involved, here is an expanded example::" msgstr "" -"Pour afficher les IDs des processus impliqués, voici un exemple plus " -"étoffé ::" +"Voici un exemple plus étoffé qui affiche les identifiants des processus " +"créés ::" #: library/multiprocessing.rst:85 msgid "" @@ -3815,16 +3815,16 @@ msgid "" "An ``'AF_INET'`` address is a tuple of the form ``(hostname, port)`` where " "*hostname* is a string and *port* is an integer." msgstr "" -"Une adresse ``'AF_INET'`` est une paire de la forme ``(hostname, port)`` où " -"*hostname* est une chaîne et *port* un entier." +"une adresse ``'AF_INET'`` est une paire de la forme ``(hostname, port)`` où " +"*hostname* est une chaîne et *port* un entier ;" #: library/multiprocessing.rst:2568 msgid "" "An ``'AF_UNIX'`` address is a string representing a filename on the " "filesystem." msgstr "" -"Une adresse ``'AF_UNIX'`` est une chaîne représentant un nom de fichier sur " -"le système de fichiers." +"une adresse ``'AF_UNIX'`` est une chaîne représentant un nom de fichier sur " +"le système de fichiers ;" #: library/multiprocessing.rst:2571 msgid "" @@ -3833,11 +3833,11 @@ msgid "" "remote computer called *ServerName* one should use an address of the form :" "samp:`r'\\\\\\\\{ServerName}\\\\pipe\\\\{PipeName}'` instead." msgstr "" -"Une adresse ``'AF_PIPE'`` est une chaîne de caractères de la forme :samp:" -"`r'\\\\\\\\.\\\\pipe\\\\{PipeName}'`. Pour utiliser :func:`Client` pour se " -"connecter à un tube nommé sur une machine distante appelée *ServerName*, il " -"faut utiliser une adresse de la forme :samp:`r'\\\\\\\\{ServerName}\\\\pipe\\" -"\\{PipeName}'`." +"une adresse ``'AF_PIPE'`` est une chaîne de caractères de la forme :samp:" +"`r'\\\\\\\\.\\\\pipe\\\\{NomDuTube}'`. Pour utiliser :func:`Client` pour se " +"connecter à un tube nommé sur une machine distante appelée *NomDeLaMachine*, " +"il faut utiliser une adresse de la forme :samp:`r'\\\\\\\\{NomDeLaMachine}\\" +"\\pipe\\\\{NomDuTube}'`." #: library/multiprocessing.rst:2576 msgid "" @@ -4234,15 +4234,15 @@ msgstr "" #: library/multiprocessing.rst:2785 msgid "An example which will deadlock is the following::" -msgstr "L'exemple suivant provoquera un interblocage ::" +msgstr "L'exemple suivant provoque un interblocage ::" #: library/multiprocessing.rst:2799 msgid "" "A fix here would be to swap the last two lines (or simply remove the ``p." "join()`` line)." msgstr "" -"Une solution ici serait d'intervertir les deux dernières lignes (ou " -"simplement supprimer la ligne ``p.join()``)." +"Une solution ici consiste à intervertir les deux dernières lignes (ou " +"simplement à supprimer la ligne ``p.join()``)." #: library/multiprocessing.rst:2802 msgid "Explicitly pass resources to child processes" @@ -4255,7 +4255,7 @@ msgid "" "However, it is better to pass the object as an argument to the constructor " "for the child process." msgstr "" -"Sous Unix en utilisant la méthode de démarrage *fork*, un processus fils " +"Sous Unix, en utilisant la méthode de démarrage *fork*, un processus fils " "peut utiliser une ressource partagée créée par un processus parent en " "utilisant une ressource globale. Cependant, il est préférable de passer " "l'objet en argument au constructeur du processus fils." From c923847c905d58cfbc9bb2df728d0e6dc8a571d1 Mon Sep 17 00:00:00 2001 From: Antoine Wecxsteen Date: Tue, 20 Jul 2021 20:17:13 +0200 Subject: [PATCH 10/10] =?UTF-8?q?Correction=20remont=C3=A9e=20par=20padpo.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- library/multiprocessing.po | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/library/multiprocessing.po b/library/multiprocessing.po index 3b0d5d15e..e1b090dd0 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -2199,7 +2199,7 @@ msgid "" "insufficient to just do ::" msgstr "" "Les opérations telles que ``+=`` qui impliquent une lecture et une écriture " -"ne sont pas atomique. Ainsi si vous souhaitez par exemple réaliser une " +"ne sont pas atomiques. Ainsi si vous souhaitez par exemple réaliser une " "incrémentation atomique sur une valeur partagée, vous ne pouvez pas " "simplement faire ::"