diff --git a/dict b/dict index 3ff36512..fa1a8e27 100644 --- a/dict +++ b/dict @@ -14,10 +14,14 @@ coroutine coroutines d'allocateurs déduplication +désenregistre déserialisations déserialise +désérialise désérialisé +désérialisées déserialiser +désérialiser déserialisés déserialiseur déserialiseurs @@ -41,6 +45,7 @@ interchangés itérateur itérateurs journaliser +journaliseur Jr. Kuchling l'allocateur @@ -79,6 +84,7 @@ sérialiser sérialiseur Serwy shell +slot tokenisation tokenisé tokenisés diff --git a/library/multiprocessing.po b/library/multiprocessing.po index dc6f996e..742b3ad2 100644 --- a/library/multiprocessing.po +++ b/library/multiprocessing.po @@ -6,22 +6,22 @@ msgstr "" "Project-Id-Version: Python 3.6\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2018-06-28 15:29+0200\n" -"PO-Revision-Date: 2018-09-30 22:25+0200\n" +"PO-Revision-Date: 2018-10-15 21:48+0200\n" "Last-Translator: Julien Palard \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 1.8.11\n" +"X-Generator: Poedit 2.1.1\n" #: ../Doc/library/multiprocessing.rst:2 msgid ":mod:`multiprocessing` --- Process-based parallelism" -msgstr "" +msgstr ":mod:`multiprocessing` --- Parallélisme par processus" #: ../Doc/library/multiprocessing.rst:7 msgid "**Source code:** :source:`Lib/multiprocessing/`" -msgstr "" +msgstr "**Code source :** :source:`Lib/multiprocessing/`" #: ../Doc/library/multiprocessing.rst:12 msgid "Introduction" @@ -37,6 +37,14 @@ msgid "" "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` offre à la fois des possibilités de programmation " +"concurrente locale ou à distance, contournant 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." #: ../Doc/library/multiprocessing.rst:22 msgid "" @@ -50,14 +58,22 @@ msgid "" "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. L'exemple basique de " +"parallélisme de données utilise :class:`~multiprocessing.pool.Pool`, ::" #: ../Doc/library/multiprocessing.rst:40 msgid "will print to standard output ::" -msgstr "" +msgstr "affiche sur la sortie standard : ::" #: ../Doc/library/multiprocessing.rst:46 msgid "The :class:`Process` class" -msgstr "" +msgstr "La classe :class:`Process`" #: ../Doc/library/multiprocessing.rst:48 msgid "" @@ -66,27 +82,37 @@ msgid "" "`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." +"Thread`. Un exemple trivial d'un programme multi-processus est : ::" #: ../Doc/library/multiprocessing.rst:63 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é : ::" #: ../Doc/library/multiprocessing.rst:84 msgid "" "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`." #: ../Doc/library/multiprocessing.rst:90 msgid "Contexts and start methods" -msgstr "" +msgstr "Contextes et méthodes de démarrage" #: ../Doc/library/multiprocessing.rst:94 msgid "" "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" #: ../Doc/library/multiprocessing.rst:105 msgid "*spawn*" @@ -101,10 +127,16 @@ msgid "" "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*." #: ../Doc/library/multiprocessing.rst:105 msgid "Available on Unix and Windows. The default on Windows." -msgstr "" +msgstr "Disponible sur Unix et Windows. Par défaut sur Windows." #: ../Doc/library/multiprocessing.rst:114 msgid "*fork*" @@ -117,14 +149,19 @@ msgid "" "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é*." #: ../Doc/library/multiprocessing.rst:114 msgid "Available on Unix only. The default on Unix." -msgstr "" +msgstr "Disponible uniquement sous Unix. Par défaut sous Unix." #: ../Doc/library/multiprocessing.rst:125 msgid "*forkserver*" -msgstr "" +msgstr "*forkserver*" #: ../Doc/library/multiprocessing.rst:117 msgid "" @@ -134,12 +171,20 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:124 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." #: ../Doc/library/multiprocessing.rst:127 msgid "" @@ -147,6 +192,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:133 msgid "" @@ -159,17 +207,31 @@ msgid "" "system allows only a limited number, and they will not be automatically " "unlinked until the next reboot.)" msgstr "" +"Sous Unix, utiliser les méthodes de démarrage *spawn* ou *forkserver* " +"démarre aussi un processus *semaphore tracker* qui traque les sémaphores " +"nommés non libérés créés par les processus du programme. Quand tous les " +"processus sont terminés, le traqueur de sémaphores libère les sémaphores " +"restants. Généralement il ne devrait pas y en avoir, mais si un processus a " +"été tué par un signal, certains sémaphores ont pu « fuiter ». (Libérer les " +"sémaphores nommés est une affaire sérieuse puisque le système n'en autorise " +"qu'un certain nombre, et qu'ils ne seront pas automatiquement libérés avant " +"le prochain redémarrage.)" #: ../Doc/library/multiprocessing.rst:142 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::" 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 : ::" #: ../Doc/library/multiprocessing.rst:159 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." #: ../Doc/library/multiprocessing.rst:162 msgid "" @@ -177,6 +239,10 @@ msgid "" "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 " +"programme. ::" #: ../Doc/library/multiprocessing.rst:180 msgid "" @@ -185,22 +251,31 @@ msgid "" "*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*." #: ../Doc/library/multiprocessing.rst:185 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." 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." #: ../Doc/library/multiprocessing.rst:191 msgid "Exchanging objects between processes" -msgstr "" +msgstr "Échange d'objets entre les processus" #: ../Doc/library/multiprocessing.rst:193 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 :" #: ../Doc/library/multiprocessing.rst:196 msgid "**Queues**" @@ -211,20 +286,26 @@ 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 : ::" #: ../Doc/library/multiprocessing.rst:213 msgid "Queues are thread and process safe." msgstr "" +"Les queues peuvent être utilisées par plusieurs fils d'exécution ou " +"processus." #: ../Doc/library/multiprocessing.rst:215 msgid "**Pipes**" -msgstr "**Pipes**" +msgstr "**Tubes** (*pipes*)" #: ../Doc/library/multiprocessing.rst:217 msgid "" "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 à double-sens. Par exemple : ::" #: ../Doc/library/multiprocessing.rst:233 msgid "" @@ -235,10 +316,17 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:243 msgid "Synchronization between processes" -msgstr "" +msgstr "Synchronisation entre processus" #: ../Doc/library/multiprocessing.rst:245 msgid "" @@ -246,16 +334,22 @@ msgid "" "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 : ::" #: ../Doc/library/multiprocessing.rst:264 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." #: ../Doc/library/multiprocessing.rst:269 msgid "Sharing state between processes" -msgstr "" +msgstr "Partager un état entre les processus" #: ../Doc/library/multiprocessing.rst:271 msgid "" @@ -263,27 +357,34 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:275 msgid "" "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." #: ../Doc/library/multiprocessing.rst:278 msgid "**Shared memory**" -msgstr "" +msgstr "**Mémoire partagée**" #: ../Doc/library/multiprocessing.rst:280 msgid "" "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 : ::" #: ../Doc/library/multiprocessing.rst:301 #: ../Doc/library/multiprocessing.rst:347 msgid "will print ::" -msgstr "" +msgstr "affiche : ::" #: ../Doc/library/multiprocessing.rst:306 msgid "" @@ -292,6 +393,11 @@ msgid "" "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 partagés seront sûr d'utilisation entre processus et fils " +"d'exécution." #: ../Doc/library/multiprocessing.rst:311 msgid "" @@ -299,10 +405,13 @@ msgid "" "`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." #: ../Doc/library/multiprocessing.rst:315 msgid "**Server process**" -msgstr "" +msgstr "** Processus serveur**" #: ../Doc/library/multiprocessing.rst:317 msgid "" @@ -310,6 +419,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:321 msgid "" @@ -319,6 +431,11 @@ msgid "" "`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, ::" #: ../Doc/library/multiprocessing.rst:352 msgid "" @@ -327,10 +444,15 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:359 msgid "Using a pool of workers" -msgstr "" +msgstr "Utiliser un réservoir de *workers*" #: ../Doc/library/multiprocessing.rst:361 msgid "" @@ -338,16 +460,21 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:365 msgid "For example::" -msgstr "Par exemple ::" +msgstr "Par exemple : ::" #: ../Doc/library/multiprocessing.rst:409 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." #: ../Doc/library/multiprocessing.rst:414 msgid "" @@ -357,6 +484,11 @@ msgid "" "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 : ::" #: ../Doc/library/multiprocessing.rst:436 msgid "" @@ -364,20 +496,25 @@ msgid "" "in a semi-random fashion, and then you may have to stop the master 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 aurez alors à stopper le " +"processus maître.)" #: ../Doc/library/multiprocessing.rst:442 msgid "Reference" -msgstr "" +msgstr "Référence" #: ../Doc/library/multiprocessing.rst:444 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`." #: ../Doc/library/multiprocessing.rst:449 msgid ":class:`Process` and exceptions" -msgstr "" +msgstr ":class:`Process` et exceptions" #: ../Doc/library/multiprocessing.rst:454 msgid "" @@ -385,6 +522,9 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:458 msgid "" @@ -399,10 +539,20 @@ msgid "" "``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 *tuple* 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." #: ../Doc/library/multiprocessing.rst:469 msgid "By default, no arguments are passed to *target*." -msgstr "" +msgstr "Par défaut, aucun argument n'est passé à *target*." #: ../Doc/library/multiprocessing.rst:471 msgid "" @@ -410,14 +560,17 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:475 msgid "Added the *daemon* argument." -msgstr "" +msgstr "Ajout de l'argument *daemon*." #: ../Doc/library/multiprocessing.rst:480 msgid "Method representing the process's activity." -msgstr "" +msgstr "Méthode représentant l'activité du processus." #: ../Doc/library/multiprocessing.rst:482 msgid "" @@ -426,16 +579,23 @@ msgid "" "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 " +"respectivement pris depuis les paramètres *args* et *kwargs*." #: ../Doc/library/multiprocessing.rst:489 msgid "Start the process's activity." -msgstr "" +msgstr "Démarre l'activité du processus." #: ../Doc/library/multiprocessing.rst:491 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." 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é." #: ../Doc/library/multiprocessing.rst:496 msgid "" @@ -446,22 +606,34 @@ msgid "" "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é." #: ../Doc/library/multiprocessing.rst:503 msgid "A process can be joined many times." -msgstr "" +msgstr "*join* peut être appelée plusieurs fois sur un même processus." #: ../Doc/library/multiprocessing.rst:505 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." 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é." #: ../Doc/library/multiprocessing.rst:510 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." 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." #: ../Doc/library/multiprocessing.rst:514 msgid "" @@ -470,32 +642,42 @@ msgid "" "`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-" +"ième enfant de son parent." #: ../Doc/library/multiprocessing.rst:521 msgid "Return whether the process is alive." -msgstr "" +msgstr "Renvoie vrai si le processus est en vie, faux sinon." #: ../Doc/library/multiprocessing.rst:523 msgid "" "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." #: ../Doc/library/multiprocessing.rst:528 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." #: ../Doc/library/multiprocessing.rst:531 msgid "The initial value is inherited from the creating process." -msgstr "" +msgstr "La valeur initiale est héritée par le processus créateur." #: ../Doc/library/multiprocessing.rst:533 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*." #: ../Doc/library/multiprocessing.rst:536 msgid "" @@ -505,17 +687,26 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:542 msgid "" "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 :" #: ../Doc/library/multiprocessing.rst:547 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``." #: ../Doc/library/multiprocessing.rst:552 msgid "" @@ -523,16 +714,21 @@ msgid "" "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*." #: ../Doc/library/multiprocessing.rst:558 msgid "The process's authentication key (a byte string)." -msgstr "" +msgstr "La clé d'authentification du processus (une chaîne d'octets)." #: ../Doc/library/multiprocessing.rst:560 msgid "" "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`." #: ../Doc/library/multiprocessing.rst:563 msgid "" @@ -540,16 +736,21 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:567 msgid "See :ref:`multiprocessing-auth-keys`." -msgstr "" +msgstr "Voir :ref:`multiprocessing-auth-keys`." #: ../Doc/library/multiprocessing.rst:571 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." #: ../Doc/library/multiprocessing.rst:574 msgid "" @@ -557,6 +758,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:578 msgid "" @@ -564,6 +768,10 @@ msgid "" "``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`." #: ../Doc/library/multiprocessing.rst:586 msgid "" @@ -571,12 +779,18 @@ msgid "" "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 " +"exécutées." #: ../Doc/library/multiprocessing.rst:590 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." #: ../Doc/library/multiprocessing.rst:595 msgid "" @@ -586,10 +800,17 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:603 msgid "Same as :meth:`terminate()` but using the ``SIGKILL`` signal on Unix." msgstr "" +"Identique à :meth:`terminate()` mais utilisant le signal ``SIGKILL`` sous " +"Unix." #: ../Doc/library/multiprocessing.rst:609 msgid "" @@ -598,6 +819,11 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:617 msgid "" @@ -605,38 +831,46 @@ msgid "" "`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*." #: ../Doc/library/multiprocessing.rst:621 msgid "Example usage of some of the methods of :class:`Process`:" -msgstr "" +msgstr "Exemple d'utilisation de quelques méthodes de :class:`Process` :" #: ../Doc/library/multiprocessing.rst:641 msgid "The base class of all :mod:`multiprocessing` exceptions." -msgstr "" +msgstr "La classe de base de toutes les exceptions de :mod:`multiprocessing`." #: ../Doc/library/multiprocessing.rst:645 msgid "" "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." #: ../Doc/library/multiprocessing.rst:648 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." #: ../Doc/library/multiprocessing.rst:653 msgid "Raised when there is an authentication error." -msgstr "" +msgstr "Levée quand il y a une erreur d'authentification." #: ../Doc/library/multiprocessing.rst:657 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." #: ../Doc/library/multiprocessing.rst:660 msgid "Pipes and Queues" -msgstr "" +msgstr "Tubes (*pipes*) et Queues" #: ../Doc/library/multiprocessing.rst:662 msgid "" @@ -644,12 +878,18 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:666 msgid "" "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)." #: ../Doc/library/multiprocessing.rst:669 msgid "" @@ -660,6 +900,12 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:676 msgid "" @@ -668,12 +914,18 @@ msgid "" "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 " +"éventuellement déborder, levant une exception." #: ../Doc/library/multiprocessing.rst:681 msgid "" "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`." #: ../Doc/library/multiprocessing.rst:686 msgid "" @@ -681,6 +933,10 @@ msgid "" "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 nom :mod:`multiprocessing` " +"donc vous devez les importer depuis le module :mod:`queue`." #: ../Doc/library/multiprocessing.rst:693 msgid "" @@ -690,6 +946,12 @@ msgid "" "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 `." #: ../Doc/library/multiprocessing.rst:700 msgid "" @@ -697,6 +959,10 @@ msgid "" "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 " +"de :exc:`queue.Empty`." #: ../Doc/library/multiprocessing.rst:705 msgid "" @@ -705,6 +971,10 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:712 msgid "" @@ -713,6 +983,11 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:719 msgid "" @@ -721,6 +996,11 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:724 msgid "" @@ -730,24 +1010,35 @@ msgid "" "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*." #: ../Doc/library/multiprocessing.rst:729 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`." #: ../Doc/library/multiprocessing.rst:732 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`." #: ../Doc/library/multiprocessing.rst:738 msgid "" "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." #: ../Doc/library/multiprocessing.rst:742 msgid "" @@ -756,6 +1047,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:750 msgid "" @@ -763,42 +1057,62 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:754 msgid "" "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*." #: ../Doc/library/multiprocessing.rst:757 msgid "" ":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`." #: ../Doc/library/multiprocessing.rst:762 msgid "" "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*." #: ../Doc/library/multiprocessing.rst:765 msgid "" "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." #: ../Doc/library/multiprocessing.rst:770 msgid "" "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*." #: ../Doc/library/multiprocessing.rst:775 msgid "" "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*." #: ../Doc/library/multiprocessing.rst:780 msgid "" @@ -810,10 +1124,18 @@ msgid "" "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)." #: ../Doc/library/multiprocessing.rst:791 msgid "Equivalent to ``put(obj, False)``." -msgstr "" +msgstr "Équivalent à ``put(obj, False)``." #: ../Doc/library/multiprocessing.rst:795 msgid "" @@ -825,6 +1147,15 @@ msgid "" "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)." #: ../Doc/library/multiprocessing.rst:805 msgid "Equivalent to ``get(False)``." @@ -835,6 +1166,9 @@ msgid "" ":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 :" #: ../Doc/library/multiprocessing.rst:813 msgid "" @@ -843,6 +1177,10 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:820 msgid "" @@ -850,6 +1188,10 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:824 msgid "" @@ -857,6 +1199,10 @@ msgid "" "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:" +"`join_thread` ne fasse rien." #: ../Doc/library/multiprocessing.rst:830 msgid "" @@ -864,6 +1210,9 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:834 msgid "" @@ -873,6 +1222,12 @@ msgid "" "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 " +"inquiétez pas de perdre des données." #: ../Doc/library/multiprocessing.rst:843 msgid "" @@ -883,29 +1238,39 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:852 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." #: ../Doc/library/multiprocessing.rst:856 msgid "Return ``True`` if the queue is empty, ``False`` otherwise." -msgstr "" +msgstr "Renvoie ``True`` si la queue est vide, ``False`` sinon." #: ../Doc/library/multiprocessing.rst:860 msgid "Remove and return an item from the queue." -msgstr "Supprime et donne un élément de la queue." +msgstr "Supprime et renvoie un élément de la queue." #: ../Doc/library/multiprocessing.rst:864 msgid "Put *item* into the queue." -msgstr "" +msgstr "Place *item* dans la queue." #: ../Doc/library/multiprocessing.rst:869 msgid "" ":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`." #: ../Doc/library/multiprocessing.rst:874 msgid "" @@ -914,6 +1279,10 @@ msgid "" "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é." #: ../Doc/library/multiprocessing.rst:879 msgid "" @@ -921,6 +1290,10 @@ msgid "" "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)." #: ../Doc/library/multiprocessing.rst:883 msgid "" @@ -933,6 +1306,8 @@ msgstr "" #: ../Doc/library/multiprocessing.rst:889 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." #: ../Doc/library/multiprocessing.rst:891 msgid "" @@ -942,24 +1317,31 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:899 msgid "Miscellaneous" -msgstr "" +msgstr "Divers" #: ../Doc/library/multiprocessing.rst:903 msgid "Return list of all live children of the current process." -msgstr "" +msgstr "Renvoie la liste de tous les enfants vivants du processus courant." #: ../Doc/library/multiprocessing.rst:905 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é." #: ../Doc/library/multiprocessing.rst:910 msgid "Return the number of CPUs in the system." -msgstr "" +msgstr "Renvoie le nombre de CPU sur le système." #: ../Doc/library/multiprocessing.rst:912 msgid "" @@ -973,20 +1355,20 @@ msgstr "" #: ../Doc/library/multiprocessing.rst:916 msgid "May raise :exc:`NotImplementedError`." -msgstr "" +msgstr "Peut lever une :exc:`NotImplementedError`." #: ../Doc/library/multiprocessing.rst:919 msgid ":func:`os.cpu_count`" -msgstr "" +msgstr ":func:`os.cpu_count`" #: ../Doc/library/multiprocessing.rst:923 msgid "" "Return the :class:`Process` object corresponding to the current process." -msgstr "" +msgstr "Renvoie l'objet :class:`Process` correspondant au processus courant." #: ../Doc/library/multiprocessing.rst:925 msgid "An analogue of :func:`threading.current_thread`." -msgstr "" +msgstr "Un analogue à :func:`threading.current_thread`." #: ../Doc/library/multiprocessing.rst:929 msgid "" @@ -994,18 +1376,25 @@ msgid "" "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é gelés pour produire un exécutable Windows. (Testé avec **py2exe**, " +"**PyInstaller** et **cx_Freeze**.)" #: ../Doc/library/multiprocessing.rst:933 msgid "" "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 : ::" #: ../Doc/library/multiprocessing.rst:945 msgid "" "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 gelé lèvera une :exc:`RuntimeError`." #: ../Doc/library/multiprocessing.rst:948 msgid "" @@ -1014,6 +1403,10 @@ msgid "" "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é " +"gelé), alors ``freeze_support()`` n'a pas d'effet." #: ../Doc/library/multiprocessing.rst:955 msgid "" @@ -1023,12 +1416,19 @@ msgid "" "``'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." #: ../Doc/library/multiprocessing.rst:965 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`." #: ../Doc/library/multiprocessing.rst:968 msgid "" @@ -1036,10 +1436,16 @@ msgid "" "*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." #: ../Doc/library/multiprocessing.rst:977 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." #: ../Doc/library/multiprocessing.rst:979 msgid "" @@ -1047,6 +1453,10 @@ msgid "" "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é." #: ../Doc/library/multiprocessing.rst:984 msgid "" @@ -1054,6 +1464,9 @@ msgid "" "``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." #: ../Doc/library/multiprocessing.rst:992 msgid "" @@ -1061,26 +1474,36 @@ msgid "" "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 : ::" #: ../Doc/library/multiprocessing.rst:998 msgid "before they can create child processes." -msgstr "" +msgstr "avant de pouvoir créer des processus fils." #: ../Doc/library/multiprocessing.rst:1000 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." #: ../Doc/library/multiprocessing.rst:1005 msgid "" "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'``." #: ../Doc/library/multiprocessing.rst:1008 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." 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." #: ../Doc/library/multiprocessing.rst:1016 msgid "" @@ -1089,34 +1512,49 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1023 msgid "Connection Objects" -msgstr "" +msgstr "Objets de connexions" #: ../Doc/library/multiprocessing.rst:1027 msgid "" "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." #: ../Doc/library/multiprocessing.rst:1030 msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1038 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`." #: ../Doc/library/multiprocessing.rst:1041 msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1046 msgid "" @@ -1124,22 +1562,29 @@ 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é." #: ../Doc/library/multiprocessing.rst:1053 msgid "Return the file descriptor or handle used by the connection." msgstr "" +"Renvoie le descripteur de fichier ou identifiant utilisé par la connexion." #: ../Doc/library/multiprocessing.rst:1057 msgid "Close the connection." -msgstr "" +msgstr "Ferme la connexion." #: ../Doc/library/multiprocessing.rst:1059 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." #: ../Doc/library/multiprocessing.rst:1063 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." #: ../Doc/library/multiprocessing.rst:1065 msgid "" @@ -1147,16 +1592,23 @@ msgid "" "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é." #: ../Doc/library/multiprocessing.rst:1069 msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1074 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." #: ../Doc/library/multiprocessing.rst:1076 msgid "" @@ -1165,6 +1617,11 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1083 msgid "" @@ -1173,18 +1630,26 @@ 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é." #: ../Doc/library/multiprocessing.rst:1088 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." 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." #: ../Doc/library/multiprocessing.rst:1092 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`." #: ../Doc/library/multiprocessing.rst:1099 msgid "" @@ -1193,6 +1658,11 @@ msgid "" "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é." #: ../Doc/library/multiprocessing.rst:1105 msgid "" @@ -1200,6 +1670,10 @@ msgid "" "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* (en octets)." #: ../Doc/library/multiprocessing.rst:1110 msgid "" @@ -1207,12 +1681,18 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1114 msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1118 msgid "" @@ -1220,6 +1700,10 @@ msgid "" "`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`." #: ../Doc/library/multiprocessing.rst:1123 msgid "For example:" @@ -1231,6 +1715,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1151 msgid "" @@ -1239,6 +1726,10 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1158 msgid "" @@ -1246,10 +1737,13 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1164 msgid "Synchronization primitives" -msgstr "" +msgstr "Primitives de synchronisation" #: ../Doc/library/multiprocessing.rst:1168 msgid "" @@ -1257,22 +1751,29 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1172 msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1177 msgid "A barrier object: a clone of :class:`threading.Barrier`." -msgstr "" +msgstr "Un objet barrière : un clone de :class:`threading.Barrier`." #: ../Doc/library/multiprocessing.rst:1183 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`." #: ../Doc/library/multiprocessing.rst:1186 #: ../Doc/library/multiprocessing.rst:1324 @@ -1280,31 +1781,39 @@ 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`." 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`." #: ../Doc/library/multiprocessing.rst:1190 msgid "" "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." #: ../Doc/library/multiprocessing.rst:1195 msgid "A condition variable: an alias for :class:`threading.Condition`." msgstr "" +"Une variable conditionnelle : un alias pour :class:`threading.Condition`." #: ../Doc/library/multiprocessing.rst:1197 msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1200 #: ../Doc/library/multiprocessing.rst:1734 msgid "The :meth:`~threading.Condition.wait_for` method was added." -msgstr "" +msgstr "La méthode :meth:`~threading.Condition.wait_for` a été ajoutée." #: ../Doc/library/multiprocessing.rst:1205 msgid "A clone of :class:`threading.Event`." -msgstr "" +msgstr "Un clone de :class:`threading.Event`." #: ../Doc/library/multiprocessing.rst:1210 msgid "" @@ -1316,6 +1825,14 @@ msgid "" "`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é." #: ../Doc/library/multiprocessing.rst:1218 msgid "" @@ -1323,17 +1840,22 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1222 msgid "" ":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`." #: ../Doc/library/multiprocessing.rst:1227 #: ../Doc/library/multiprocessing.rst:1278 msgid "Acquire a lock, blocking or non-blocking." -msgstr "" +msgstr "Acquiert un verrou, bloquant ou non bloquant." #: ../Doc/library/multiprocessing.rst:1229 msgid "" @@ -1342,6 +1864,10 @@ msgid "" "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 " +"celui de :meth:`threading.Lock.acquire`." #: ../Doc/library/multiprocessing.rst:1234 msgid "" @@ -1349,6 +1875,9 @@ msgid "" "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``." #: ../Doc/library/multiprocessing.rst:1238 msgid "" @@ -1363,18 +1892,34 @@ msgid "" "``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é." #: ../Doc/library/multiprocessing.rst:1253 msgid "" "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." #: ../Doc/library/multiprocessing.rst:1256 msgid "" "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." #: ../Doc/library/multiprocessing.rst:1262 msgid "" @@ -1384,6 +1929,11 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1268 msgid "" @@ -1391,12 +1941,17 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1272 msgid "" ":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`." #: ../Doc/library/multiprocessing.rst:1280 msgid "" @@ -1410,6 +1965,14 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1290 msgid "" @@ -1421,6 +1984,12 @@ msgid "" "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``." #: ../Doc/library/multiprocessing.rst:1298 msgid "" @@ -1428,6 +1997,9 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1305 msgid "" @@ -1438,6 +2010,13 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1313 msgid "" @@ -1447,16 +2026,24 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1322 msgid "A semaphore object: a close analog of :class:`threading.Semaphore`." -msgstr "" +msgstr "Un objet sémaphore, proche analogue de :class:`threading.Semaphore`." #: ../Doc/library/multiprocessing.rst:1329 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." 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." #: ../Doc/library/multiprocessing.rst:1334 msgid "" @@ -1466,12 +2053,19 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1340 msgid "" "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." #: ../Doc/library/multiprocessing.rst:1345 msgid "" @@ -1481,16 +2075,23 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1353 msgid "Shared :mod:`ctypes` Objects" -msgstr "" +msgstr "Objets :mod:`ctypes` partagés" #: ../Doc/library/multiprocessing.rst:1355 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." #: ../Doc/library/multiprocessing.rst:1360 msgid "" @@ -1498,6 +2099,10 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1364 #: ../Doc/library/multiprocessing.rst:1451 @@ -1506,6 +2111,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1368 msgid "" @@ -1516,6 +2124,12 @@ msgid "" "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* »" #: ../Doc/library/multiprocessing.rst:1375 msgid "" @@ -1523,24 +2137,32 @@ msgid "" "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 : ::" #: ../Doc/library/multiprocessing.rst:1381 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 : ::" #: ../Doc/library/multiprocessing.rst:1387 #: ../Doc/library/multiprocessing.rst:1477 #: ../Doc/library/multiprocessing.rst:1492 msgid "Note that *lock* is a keyword-only argument." -msgstr "" +msgstr "Notez que *lock* est un argument *keyword-only*." #: ../Doc/library/multiprocessing.rst:1391 msgid "" "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." #: ../Doc/library/multiprocessing.rst:1394 msgid "" @@ -1551,6 +2173,12 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1401 msgid "" @@ -1561,20 +2189,29 @@ msgid "" "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* »" #: ../Doc/library/multiprocessing.rst:1408 msgid "Note that *lock* is a keyword only argument." -msgstr "" +msgstr "Notez que *lock* est un argument *keyword-only*." #: ../Doc/library/multiprocessing.rst:1410 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." 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." #: ../Doc/library/multiprocessing.rst:1415 msgid "The :mod:`multiprocessing.sharedctypes` module" -msgstr "" +msgstr "Le module :mod:`multiprocessing.sharedctypes`" #: ../Doc/library/multiprocessing.rst:1420 msgid "" @@ -1582,6 +2219,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1426 msgid "" @@ -1591,10 +2231,15 @@ msgid "" "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 dans une mémoire partagée, " +"souvenez-vous qu'il référencera un emplacement dans l'espace d'adressage " +"d'un processus particulier. Ainsi, le pointeur risque d'être invalide dans " +"le contexte d'un second processus et déréférencer le pointeur depuis ce " +"second processus pourrait causer un crash." #: ../Doc/library/multiprocessing.rst:1434 msgid "Return a ctypes array allocated from shared memory." -msgstr "" +msgstr "Renvoie un tableau *ctypes* alloué depuis la mémoire partagée." #: ../Doc/library/multiprocessing.rst:1436 msgid "" @@ -1605,6 +2250,13 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1443 msgid "" @@ -1612,10 +2264,13 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1449 msgid "Return a ctypes object allocated from shared memory." -msgstr "" +msgstr "Renvoie un objet *ctypes* alloué depuis la mémoire partagée." #: ../Doc/library/multiprocessing.rst:1455 msgid "" @@ -1623,6 +2278,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1459 msgid "" @@ -1630,6 +2288,9 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1465 msgid "" @@ -1637,6 +2298,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1469 #: ../Doc/library/multiprocessing.rst:1485 @@ -1648,6 +2312,12 @@ msgid "" "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* »" #: ../Doc/library/multiprocessing.rst:1481 msgid "" @@ -1655,12 +2325,17 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1496 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*." #: ../Doc/library/multiprocessing.rst:1501 msgid "" @@ -1668,6 +2343,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1505 msgid "" @@ -1675,16 +2353,22 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1509 msgid "" "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." #: ../Doc/library/multiprocessing.rst:1512 msgid "Synchronized objects support the :term:`context manager` protocol." msgstr "" +"Les objets synchronisés supportent le protocole :term:`context manager`." #: ../Doc/library/multiprocessing.rst:1516 msgid "" @@ -1692,6 +2376,10 @@ msgid "" "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." +"Structure`.)" #: ../Doc/library/multiprocessing.rst:1521 msgid "ctypes" @@ -1699,11 +2387,11 @@ msgstr "ctypes" #: ../Doc/library/multiprocessing.rst:1521 msgid "sharedctypes using type" -msgstr "" +msgstr "*sharedctypes* utilisant un type" #: ../Doc/library/multiprocessing.rst:1521 msgid "sharedctypes using typecode" -msgstr "" +msgstr "*sharedctypes* utilisant un *typecode*" #: ../Doc/library/multiprocessing.rst:1523 msgid "c_double(2.4)" @@ -1754,14 +2442,16 @@ 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 ::" #: ../Doc/library/multiprocessing.rst:1568 msgid "The results printed are ::" -msgstr "" +msgstr "Les résultats affichés sont ::" #: ../Doc/library/multiprocessing.rst:1581 msgid "Managers" -msgstr "" +msgstr "Gestionnaires" #: ../Doc/library/multiprocessing.rst:1583 msgid "" @@ -1771,6 +2461,12 @@ msgid "" "*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." #: ../Doc/library/multiprocessing.rst:1591 msgid "" @@ -1779,6 +2475,11 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1599 msgid "" @@ -1786,10 +2487,13 @@ msgid "" "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` :" #: ../Doc/library/multiprocessing.rst:1605 msgid "Create a BaseManager object." -msgstr "" +msgstr "Crée un objet *BaseManager*." #: ../Doc/library/multiprocessing.rst:1607 msgid "" @@ -1797,12 +2501,18 @@ msgid "" "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é." #: ../Doc/library/multiprocessing.rst:1610 msgid "" "*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." #: ../Doc/library/multiprocessing.rst:1613 msgid "" @@ -1811,12 +2521,19 @@ msgid "" "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 utilisée et doit être une chaîne d'octets." #: ../Doc/library/multiprocessing.rst:1620 msgid "" "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." #: ../Doc/library/multiprocessing.rst:1625 msgid "" @@ -1824,36 +2541,47 @@ msgid "" "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` ::" #: ../Doc/library/multiprocessing.rst:1634 msgid ":class:`Server` additionally has an :attr:`address` attribute." -msgstr "" +msgstr ":class:`Server` possède en plus un attribut :attr:`address`." #: ../Doc/library/multiprocessing.rst:1638 msgid "Connect a local manager object to a remote manager process::" msgstr "" +"Connecte un objet gestionnaire local au processus gestionnaire distant ::" #: ../Doc/library/multiprocessing.rst:1646 msgid "" "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." #: ../Doc/library/multiprocessing.rst:1649 msgid "This can be called multiple times." -msgstr "" +msgstr "Cette méthode peut être appelée plusieurs fois." #: ../Doc/library/multiprocessing.rst:1653 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." #: ../Doc/library/multiprocessing.rst:1656 msgid "" "*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." #: ../Doc/library/multiprocessing.rst:1659 msgid "" @@ -1862,6 +2590,11 @@ msgid "" "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``." #: ../Doc/library/multiprocessing.rst:1665 msgid "" @@ -1869,6 +2602,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1669 msgid "" @@ -1880,6 +2616,14 @@ msgid "" "\"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 ``'_'``.)" #: ../Doc/library/multiprocessing.rst:1678 msgid "" @@ -1890,6 +2634,13 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1685 msgid "" @@ -1897,14 +2648,20 @@ msgid "" "*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``." #: ../Doc/library/multiprocessing.rst:1689 msgid ":class:`BaseManager` instances also have one read-only property:" msgstr "" +"Les instances de :class:`BaseManager` ont aussi une propriété en lecture " +"seule :" #: ../Doc/library/multiprocessing.rst:1693 msgid "The address used by the manager." -msgstr "" +msgstr "L'adresse utilisée par le gestionnaire." #: ../Doc/library/multiprocessing.rst:1695 msgid "" @@ -1913,12 +2670,19 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1701 msgid "" "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é." #: ../Doc/library/multiprocessing.rst:1706 msgid "" @@ -1926,6 +2690,9 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1710 msgid "" @@ -1933,76 +2700,104 @@ msgid "" "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 " +"dictionnaires partagés." #: ../Doc/library/multiprocessing.rst:1716 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." #: ../Doc/library/multiprocessing.rst:1723 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." #: ../Doc/library/multiprocessing.rst:1728 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." #: ../Doc/library/multiprocessing.rst:1731 msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1739 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." #: ../Doc/library/multiprocessing.rst:1743 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." #: ../Doc/library/multiprocessing.rst:1747 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." #: ../Doc/library/multiprocessing.rst:1751 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." #: ../Doc/library/multiprocessing.rst:1755 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." #: ../Doc/library/multiprocessing.rst:1759 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." #: ../Doc/library/multiprocessing.rst:1764 msgid "Create an array and return a proxy for it." -msgstr "" +msgstr "Crée un tableau et renvoie un mandataire pour cet objet." #: ../Doc/library/multiprocessing.rst:1768 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." #: ../Doc/library/multiprocessing.rst:1775 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." #: ../Doc/library/multiprocessing.rst:1780 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." #: ../Doc/library/multiprocessing.rst:1782 msgid "" @@ -2010,16 +2805,22 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:1789 msgid "A type that can register with :class:`SyncManager`." -msgstr "" +msgstr "Un type qui peut être enregistré avec :class:`SyncManager`." #: ../Doc/library/multiprocessing.rst:1791 msgid "" "A namespace object has no public methods, but does have writable attributes. " "Its representation shows the values of its attributes." msgstr "" +"Un espace de nom n'a pas de méthodes publiques, mais possède des attributs " +"accessibles en écriture. Sa représentation montre les valeurs de ses " +"attributs." #: ../Doc/library/multiprocessing.rst:1794 msgid "" @@ -2027,10 +2828,12 @@ msgid "" "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 nom, un attribut " +"débutant par ``'_'`` sera un attribut du mandataire et non de l'objet cible." #: ../Doc/library/multiprocessing.rst:1810 msgid "Customized managers" -msgstr "" +msgstr "Gestionnaires personnalisés" #: ../Doc/library/multiprocessing.rst:1812 msgid "" @@ -2038,40 +2841,51 @@ msgid "" "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 " +"exemple ::" #: ../Doc/library/multiprocessing.rst:1837 msgid "Using a remote manager" -msgstr "" +msgstr "Utiliser un gestionnaire distant" #: ../Doc/library/multiprocessing.rst:1839 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)." 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)." #: ../Doc/library/multiprocessing.rst:1842 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 ::" #: ../Doc/library/multiprocessing.rst:1854 msgid "One client can access the server as follows::" -msgstr "" +msgstr "Un client peut accéder au serveur comme suit ::" #: ../Doc/library/multiprocessing.rst:1864 msgid "Another client can also use it::" -msgstr "" +msgstr "Un autre client peut aussi l'utiliser ::" #: ../Doc/library/multiprocessing.rst:1875 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 ::" #: ../Doc/library/multiprocessing.rst:1900 msgid "Proxy Objects" -msgstr "" +msgstr "Objets mandataires" #: ../Doc/library/multiprocessing.rst:1902 msgid "" @@ -2079,6 +2893,10 @@ msgid "" "(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." #: ../Doc/library/multiprocessing.rst:1906 msgid "" @@ -2087,6 +2905,10 @@ msgid "" "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 :" #: ../Doc/library/multiprocessing.rst:1924 msgid "" @@ -2094,6 +2916,8 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:1928 msgid "" @@ -2102,10 +2926,17 @@ msgid "" "`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` :" #: ../Doc/library/multiprocessing.rst:1944 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 ::" #: ../Doc/library/multiprocessing.rst:1957 msgid "" @@ -2117,6 +2948,14 @@ msgid "" "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 ::" #: ../Doc/library/multiprocessing.rst:1976 msgid "" @@ -2124,38 +2963,51 @@ msgid "" "`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." #: ../Doc/library/multiprocessing.rst:1982 msgid "" "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 :" #: ../Doc/library/multiprocessing.rst:1990 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." #: ../Doc/library/multiprocessing.rst:1994 msgid "Proxy objects are instances of subclasses of :class:`BaseProxy`." msgstr "" +"Les objets mandataires sont des instances de sous-classes de :class:" +"`BaseProxy`." #: ../Doc/library/multiprocessing.rst:1998 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." #: ../Doc/library/multiprocessing.rst:2000 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 ::" #: ../Doc/library/multiprocessing.rst:2004 msgid "will evaluate the expression ::" -msgstr "" +msgstr "s'évalue comme ::" #: ../Doc/library/multiprocessing.rst:2008 msgid "in the manager's process." -msgstr "" +msgstr "dans le processus du gestionnaire." #: ../Doc/library/multiprocessing.rst:2010 msgid "" @@ -2163,6 +3015,9 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:2014 msgid "" @@ -2171,58 +3026,71 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:2019 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*." #: ../Doc/library/multiprocessing.rst:2022 msgid "An example of the usage of :meth:`_callmethod`:" -msgstr "" +msgstr "Un exemple d'utilisation de :meth:`_callmethod` :" #: ../Doc/library/multiprocessing.rst:2038 msgid "Return a copy of the referent." -msgstr "" +msgstr "Renvoie une copie du référent." #: ../Doc/library/multiprocessing.rst:2040 msgid "If the referent is unpicklable then this will raise an exception." -msgstr "" +msgstr "Si le référent n'est pas sérialisable, une exception est levée." #: ../Doc/library/multiprocessing.rst:2044 msgid "Return a representation of the proxy object." -msgstr "" +msgstr "Renvoie la représentation de l'objet mandataire." #: ../Doc/library/multiprocessing.rst:2048 msgid "Return the representation of the referent." -msgstr "" +msgstr "Renvoie la représentation du référent." #: ../Doc/library/multiprocessing.rst:2052 msgid "Cleanup" -msgstr "" +msgstr "Nettoyage" #: ../Doc/library/multiprocessing.rst:2054 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." 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." #: ../Doc/library/multiprocessing.rst:2057 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." #: ../Doc/library/multiprocessing.rst:2062 msgid "Process Pools" -msgstr "" +msgstr "Bassins de processus" #: ../Doc/library/multiprocessing.rst:2067 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 bassin de processus qui exécuteront les tâches qui lui " +"seront soumises avec la classe :class:`Pool`." #: ../Doc/library/multiprocessing.rst:2072 msgid "" @@ -2230,18 +3098,26 @@ msgid "" "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 bassin de processus *workers* auquel " +"sont soumises des tâches. Il supporte les résultats asynchrones avec des " +"*timeouts* et des *callabacks* et possède une implémentation parallèle de " +"*map*." #: ../Doc/library/multiprocessing.rst:2076 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." msgstr "" +"*processes* est le nombre de processus *workers* à utiliser. Si *processes* " +"est ``None``, le nombre renvoyé par :func:`os.cpu_count` est utilisé." #: ../Doc/library/multiprocessing.rst:2079 msgid "" "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." #: ../Doc/library/multiprocessing.rst:2082 msgid "" @@ -2250,6 +3126,11 @@ msgid "" "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 bassin." #: ../Doc/library/multiprocessing.rst:2087 msgid "" @@ -2258,16 +3139,22 @@ msgid "" "`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 bassin 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." #: ../Doc/library/multiprocessing.rst:2093 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éé." #: ../Doc/library/multiprocessing.rst:2096 msgid "*maxtasksperchild*" -msgstr "" +msgstr "*maxtasksperchild*" #: ../Doc/library/multiprocessing.rst:2099 msgid "*context*" @@ -2283,6 +3170,14 @@ msgid "" "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 bassin. 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 " +"bassin à 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." #: ../Doc/library/multiprocessing.rst:2114 msgid "" @@ -2291,10 +3186,15 @@ msgid "" "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 " +"plus, *func* est exécutée sur un seul des *workers* du bassin." #: ../Doc/library/multiprocessing.rst:2121 msgid "A variant of the :meth:`apply` method which returns a result object." msgstr "" +"Une variante de la méthode :meth:`apply` qui renvoie un objet résultat." #: ../Doc/library/multiprocessing.rst:2123 #: ../Doc/library/multiprocessing.rst:2148 @@ -2304,6 +3204,10 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2128 #: ../Doc/library/multiprocessing.rst:2153 @@ -2312,6 +3216,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2132 #: ../Doc/library/multiprocessing.rst:2157 @@ -2319,12 +3226,17 @@ 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é." #: ../Doc/library/multiprocessing.rst:2137 msgid "" "A parallel equivalent of the :func:`map` built-in function (it supports only " "one *iterable* argument though). It blocks until the result is ready." msgstr "" +"Un équivalent parallèle à la fonction *built-in* :func:`map` (qui ne " +"supporte cependant qu'un *itérable* en argument). Elle bloque jusqu'à ce que " +"le résultat soit prêt." #: ../Doc/library/multiprocessing.rst:2140 msgid "" @@ -2332,14 +3244,17 @@ msgid "" "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 " +"bassin 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." #: ../Doc/library/multiprocessing.rst:2146 msgid "A variant of the :meth:`.map` method which returns a result object." -msgstr "" +msgstr "Une variante de la méthode :meth:`.map` qui renvoie un objet résultat." #: ../Doc/library/multiprocessing.rst:2162 msgid "A lazier version of :meth:`map`." -msgstr "" +msgstr "Une version paresseuse de :meth:`map`." #: ../Doc/library/multiprocessing.rst:2164 msgid "" @@ -2347,6 +3262,10 @@ msgid "" "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``." #: ../Doc/library/multiprocessing.rst:2169 msgid "" @@ -2355,6 +3274,10 @@ msgid "" "``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." #: ../Doc/library/multiprocessing.rst:2176 msgid "" @@ -2362,18 +3285,25 @@ msgid "" "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*.)" #: ../Doc/library/multiprocessing.rst:2182 msgid "" "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." #: ../Doc/library/multiprocessing.rst:2185 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)]``." #: ../Doc/library/multiprocessing.rst:2192 msgid "" @@ -2381,12 +3311,17 @@ msgid "" "*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." #: ../Doc/library/multiprocessing.rst:2200 msgid "" "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." #: ../Doc/library/multiprocessing.rst:2205 msgid "" @@ -2394,12 +3329,17 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2211 msgid "" "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`." #: ../Doc/library/multiprocessing.rst:2214 msgid "" @@ -2407,12 +3347,18 @@ msgid "" "`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the pool " "object, and :meth:`~contextmanager.__exit__` calls :meth:`terminate`." msgstr "" +"Les bassins 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`." #: ../Doc/library/multiprocessing.rst:2222 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`." #: ../Doc/library/multiprocessing.rst:2227 msgid "" @@ -2421,34 +3367,45 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:2234 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." #: ../Doc/library/multiprocessing.rst:2238 msgid "Return whether the call has completed." -msgstr "" +msgstr "Renvoie ``True`` ou ``False`` suivant si la tâche est accomplie." #: ../Doc/library/multiprocessing.rst:2242 msgid "" "Return whether the call completed without raising an exception. Will raise :" "exc:`AssertionError` 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:`AssertionError` si le résultat n'est pas prêt." #: ../Doc/library/multiprocessing.rst:2245 msgid "The following example demonstrates the use of a pool::" msgstr "" +"Les exemples suivants présentent l'utilisation d'un bassin de *workers* ::" #: ../Doc/library/multiprocessing.rst:2272 msgid "Listeners and Clients" -msgstr "" +msgstr "Auditeurs et Clients" #: ../Doc/library/multiprocessing.rst:2277 msgid "" "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`." #: ../Doc/library/multiprocessing.rst:2281 msgid "" @@ -2458,12 +3415,19 @@ msgid "" "*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 " +"traiter des *sockets* ou des tubes nommés sous Windows. Il supporte aussi la " +"*digest authentication* en utilisant le module :mod:`hmac`, et pour " +"interroger de multiples connexions en même temps." #: ../Doc/library/multiprocessing.rst:2290 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." #: ../Doc/library/multiprocessing.rst:2293 msgid "" @@ -2471,24 +3435,33 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2299 msgid "" "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." #: ../Doc/library/multiprocessing.rst:2302 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." #: ../Doc/library/multiprocessing.rst:2307 msgid "" "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`." #: ../Doc/library/multiprocessing.rst:2310 msgid "" @@ -2496,6 +3469,9 @@ msgid "" "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`)" #: ../Doc/library/multiprocessing.rst:2314 #: ../Doc/library/multiprocessing.rst:2349 @@ -2506,18 +3482,27 @@ msgid "" "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`." #: ../Doc/library/multiprocessing.rst:2322 msgid "" "A wrapper for a bound socket or Windows named pipe which is 'listening' for " "connections." msgstr "" +"Un *wrapper* sur une *socket* liée ou un tube nommé sous Windows qui écoute " +"pour des connexions." #: ../Doc/library/multiprocessing.rst:2325 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 la *socket* liée ou le tube nommé de " +"l'objet auditeur." #: ../Doc/library/multiprocessing.rst:2330 msgid "" @@ -2525,6 +3510,9 @@ msgid "" "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'." #: ../Doc/library/multiprocessing.rst:2334 msgid "" @@ -2539,6 +3527,16 @@ msgid "" "then the socket will be created in a private temporary directory created " "using :func:`tempfile.mkstemp`." msgstr "" +"*family* est le type de *socket* (ou tube nommé) à utiliser. Cela peut être " +"l'une des chaînes ``'AF_INET'`` (pour une *socket* TCP), ``'AF_UNIX'`` (pour " +"une *socket* Unix) ou ``'AF_PIPE'`` (pour un tube nommé sous Windows). " +"Seulement la première d'entre elles est garantie 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``, la *socket* est créée dans un " +"répertoire temporaire privé créé avec :func:`tempfile.mkstemp`." #: ../Doc/library/multiprocessing.rst:2345 msgid "" @@ -2546,6 +3544,9 @@ msgid "" "to the :meth:`~socket.socket.listen` method of the socket once it has been " "bound." msgstr "" +"Si l'objet auditeur utilise une *socket* alors *backlog* (1 par défaut) es " +"passé à la méthode :meth:`~socket.socket.listen` de la *socket* une fois " +"qu'elle a été liée." #: ../Doc/library/multiprocessing.rst:2357 msgid "" @@ -2553,6 +3554,10 @@ msgid "" "and return a :class:`~Connection` object. If authentication is attempted and " "fails, then :exc:`~multiprocessing.AuthenticationError` is raised." msgstr "" +"Accepte une connexion sur la *socket* liée 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." #: ../Doc/library/multiprocessing.rst:2364 msgid "" @@ -2560,20 +3565,26 @@ msgid "" "automatically when the listener is garbage collected. However it is " "advisable to call it explicitly." msgstr "" +"Ferme la *socket* liée 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." #: ../Doc/library/multiprocessing.rst:2368 msgid "Listener objects have the following read-only properties:" msgstr "" +"Les objets auditeurs ont aussi les propriétés en lecture seule suivantes :" #: ../Doc/library/multiprocessing.rst:2372 msgid "The address which is being used by the Listener object." -msgstr "" +msgstr "L'adresse utilisée par l'objet auditeur." #: ../Doc/library/multiprocessing.rst:2376 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." #: ../Doc/library/multiprocessing.rst:2379 msgid "" @@ -2581,6 +3592,10 @@ msgid "" "`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`." #: ../Doc/library/multiprocessing.rst:2386 msgid "" @@ -2590,31 +3605,43 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2392 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" #: ../Doc/library/multiprocessing.rst:2395 msgid "a readable :class:`~multiprocessing.connection.Connection` object;" msgstr "" +"un objet :class:`~multiprocessing.connection.Connection` accessible en " +"lecture ;" #: ../Doc/library/multiprocessing.rst:2396 msgid "a connected and readable :class:`socket.socket` object; or" -msgstr "" +msgstr "un objet :class:`socket.socket` connecté et accessible en lecture ; ou" #: ../Doc/library/multiprocessing.rst:2397 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`." #: ../Doc/library/multiprocessing.rst:2400 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." msgstr "" +"Une connexion ou une *socket* est prête quand il y a des données disponibles " +"en lecture dessus, ou que l'autre bout a été fermé." #: ../Doc/library/multiprocessing.rst:2403 msgid "" @@ -2623,6 +3650,11 @@ msgid "" "`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." #: ../Doc/library/multiprocessing.rst:2409 msgid "" @@ -2632,10 +3664,16 @@ msgid "" "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 retourne un identifiant de *socket* ou de tube. (Notez que " +"les identifiants de tubes et de *sockets* **ne sont pas** des identifiants " +"*waitables*.)" #: ../Doc/library/multiprocessing.rst:2419 msgid "**Examples**" -msgstr "" +msgstr "**Exemples**" #: ../Doc/library/multiprocessing.rst:2421 msgid "" @@ -2643,38 +3681,47 @@ msgid "" "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 ::" #: ../Doc/library/multiprocessing.rst:2440 msgid "" "The following code connects to the server and receives some data from the " "server::" -msgstr "" +msgstr "Le code suivant se connecte au serveur et en reçoit des données ::" #: ../Doc/library/multiprocessing.rst:2457 msgid "" "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 ::" #: ../Doc/library/multiprocessing.rst:2496 msgid "Address Formats" -msgstr "" +msgstr "Formats d'adresses" #: ../Doc/library/multiprocessing.rst:2498 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 un *tuple* de la forme ``(hostname, port)`` où " +"*hostname* est une chaîne et *port* un entier." #: ../Doc/library/multiprocessing.rst:2501 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." #: ../Doc/library/multiprocessing.rst:2507 msgid "An ``'AF_PIPE'`` address is a string of the form" -msgstr "" +msgstr "Une adresse ``'AF_PIPE'`` est une chaîne de la forme" #: ../Doc/library/multiprocessing.rst:2505 msgid "" @@ -2683,16 +3730,23 @@ msgid "" "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}'`." #: ../Doc/library/multiprocessing.rst:2509 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." 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'``." #: ../Doc/library/multiprocessing.rst:2516 msgid "Authentication keys" -msgstr "" +msgstr "Clés d'authentification" #: ../Doc/library/multiprocessing.rst:2518 msgid "" @@ -2701,6 +3755,11 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2524 msgid "" @@ -2709,6 +3768,11 @@ msgid "" "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.)" #: ../Doc/library/multiprocessing.rst:2530 msgid "" @@ -2720,12 +3784,21 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2538 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`." #: ../Doc/library/multiprocessing.rst:2542 msgid "Logging" @@ -2738,12 +3811,18 @@ msgid "" "(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." #: ../Doc/library/multiprocessing.rst:2551 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éé." #: ../Doc/library/multiprocessing.rst:2554 msgid "" @@ -2751,6 +3830,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2558 msgid "" @@ -2758,6 +3840,9 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2565 msgid "" @@ -2766,52 +3851,65 @@ msgid "" "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 " +"``'[%(levelname)s/%(processName)s] %(message)s'``." #: ../Doc/library/multiprocessing.rst:2570 msgid "Below is an example session with logging turned on::" msgstr "" +"L'exemple ci-dessous présente une session avec la journalisation activée ::" #: ../Doc/library/multiprocessing.rst:2585 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`." #: ../Doc/library/multiprocessing.rst:2589 msgid "The :mod:`multiprocessing.dummy` module" -msgstr "" +msgstr "Le module :mod:`multiprocessing.dummy`" #: ../Doc/library/multiprocessing.rst:2594 msgid "" ":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'un *wrapper* autour du module :mod:`threading`." #: ../Doc/library/multiprocessing.rst:2601 msgid "Programming guidelines" -msgstr "" +msgstr "Lignes directrices de programmation" #: ../Doc/library/multiprocessing.rst:2603 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`." #: ../Doc/library/multiprocessing.rst:2608 msgid "All start methods" -msgstr "" +msgstr "Toutes les méthodes de démarrage" #: ../Doc/library/multiprocessing.rst:2610 msgid "The following applies to all start methods." -msgstr "" +msgstr "Les règles suivantes s'appliquent aux méthodes de démarrage." #: ../Doc/library/multiprocessing.rst:2612 msgid "Avoid shared state" -msgstr "" +msgstr "Éviter les états partagés" #: ../Doc/library/multiprocessing.rst:2614 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." #: ../Doc/library/multiprocessing.rst:2617 msgid "" @@ -2819,33 +3917,42 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2621 msgid "Picklability" -msgstr "" +msgstr "Sérialisation" #: ../Doc/library/multiprocessing.rst:2623 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*)." #: ../Doc/library/multiprocessing.rst:2625 msgid "Thread safety of proxies" -msgstr "" +msgstr "Sûreté des mandataires à travers les fils d'exécution" #: ../Doc/library/multiprocessing.rst:2627 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." #: ../Doc/library/multiprocessing.rst:2630 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.)" #: ../Doc/library/multiprocessing.rst:2632 msgid "Joining zombie processes" -msgstr "" +msgstr "Attendre les processus zombies" #: ../Doc/library/multiprocessing.rst:2634 msgid "" @@ -2857,10 +3964,18 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2642 msgid "Better to inherit than pickle/unpickle" -msgstr "" +msgstr "Préférez hériter que sérialiser/désérialiser" #: ../Doc/library/multiprocessing.rst:2644 msgid "" @@ -2871,10 +3986,17 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2652 msgid "Avoid terminating processes" -msgstr "" +msgstr "Éviter de terminer les processus" #: ../Doc/library/multiprocessing.rst:2654 msgid "" @@ -2883,6 +4005,10 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2660 msgid "" @@ -2890,10 +4016,13 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2664 msgid "Joining processes that use queues" -msgstr "" +msgstr "Attendre les processus qui utilisent des queues" #: ../Doc/library/multiprocessing.rst:2666 msgid "" @@ -2903,6 +4032,12 @@ msgid "" "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.)" #: ../Doc/library/multiprocessing.rst:2672 msgid "" @@ -2912,20 +4047,28 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2678 msgid "An example which will deadlock is the following::" -msgstr "" +msgstr "L'exemple suivant provoquera un interblocage ::" #: ../Doc/library/multiprocessing.rst:2692 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()``)." #: ../Doc/library/multiprocessing.rst:2695 msgid "Explicitly pass resources to child processes" -msgstr "" +msgstr "Passer explicitement les ressources aux processus fils" #: ../Doc/library/multiprocessing.rst:2697 msgid "" @@ -2934,6 +4077,10 @@ 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 " +"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." #: ../Doc/library/multiprocessing.rst:2702 msgid "" @@ -2943,28 +4090,38 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2709 msgid "So for instance ::" -msgstr "" +msgstr "Donc par exemple ::" #: ../Doc/library/multiprocessing.rst:2721 msgid "should be rewritten as ::" -msgstr "" +msgstr "devrait être réécrit comme ::" #: ../Doc/library/multiprocessing.rst:2733 msgid "Beware of replacing :data:`sys.stdin` with a \"file like object\"" msgstr "" +"Faire attention à remplacer :data:`sys.stdin` par un objet « *file-like* »" #: ../Doc/library/multiprocessing.rst:2735 msgid ":mod:`multiprocessing` originally unconditionally called::" -msgstr "" +msgstr "À l'origine, :mod:`multiprocessing` appelait inconditionnellement ::" #: ../Doc/library/multiprocessing.rst:2739 msgid "" "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 ::" #: ../Doc/library/multiprocessing.rst:2745 msgid "" @@ -2975,6 +4132,13 @@ msgid "" "`~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 " +"reprises, résultant en une corruption." #: ../Doc/library/multiprocessing.rst:2752 msgid "" @@ -2982,25 +4146,31 @@ msgid "" "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 ::" #: ../Doc/library/multiprocessing.rst:2764 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`" #: ../Doc/library/multiprocessing.rst:2767 msgid "The *spawn* and *forkserver* start methods" -msgstr "" +msgstr "Les méthodes de démarrage *spawn* et *forkserver*" #: ../Doc/library/multiprocessing.rst:2769 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*." #: ../Doc/library/multiprocessing.rst:2772 msgid "More picklability" -msgstr "" +msgstr "Plus de sérialisation" #: ../Doc/library/multiprocessing.rst:2774 msgid "" @@ -3009,10 +4179,15 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2779 msgid "Global variables" -msgstr "" +msgstr "Variables globales" #: ../Doc/library/multiprocessing.rst:2781 msgid "" @@ -3021,16 +4196,23 @@ msgid "" "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." #: ../Doc/library/multiprocessing.rst:2786 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." #: ../Doc/library/multiprocessing.rst:2789 msgid "Safe importing of main module" -msgstr "" +msgstr "Importation sûre du module principal" #: ../Doc/library/multiprocessing.rst:2791 msgid "" @@ -3038,36 +4220,49 @@ msgid "" "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)." #: ../Doc/library/multiprocessing.rst:2795 msgid "" "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` ::" #: ../Doc/library/multiprocessing.rst:2807 msgid "" "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 ::" #: ../Doc/library/multiprocessing.rst:2821 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 gelé.)" #: ../Doc/library/multiprocessing.rst:2824 msgid "" "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()``." #: ../Doc/library/multiprocessing.rst:2827 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." #: ../Doc/library/multiprocessing.rst:2834 msgid "Examples" @@ -3076,13 +4271,17 @@ msgstr "Exemples" #: ../Doc/library/multiprocessing.rst:2836 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 :" #: ../Doc/library/multiprocessing.rst:2842 msgid "Using :class:`~multiprocessing.pool.Pool`:" -msgstr "" +msgstr "En utilisant :class:`~multiprocessing.pool.Pool` :" #: ../Doc/library/multiprocessing.rst:2848 msgid "" "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 :"