# Copyright (C) 2001-2018, Python Software Foundation # For licence information, see README file. # msgid "" msgstr "" "Project-Id-Version: Python 3\n" "Report-Msgid-Bugs-To: \n" "POT-Creation-Date: 2023-01-15 22:33+0100\n" "PO-Revision-Date: 2021-07-16 22:51+0200\n" "Last-Translator: Antoine Wecxsteen\n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 2.3\n" #: library/multiprocessing.rst:2 msgid ":mod:`multiprocessing` --- Process-based parallelism" msgstr ":mod:`multiprocessing` — Parallélisme par processus" #: library/multiprocessing.rst:7 msgid "**Source code:** :source:`Lib/multiprocessing/`" msgstr "**Code source :** :source:`Lib/multiprocessing/`" #: includes/wasm-notavail.rst:None msgid ":ref:`Availability `: not Emscripten, not WASI." msgstr "" #: includes/wasm-notavail.rst:5 msgid "" "This module does not work or is not available on WebAssembly platforms " "``wasm32-emscripten`` and ``wasm32-wasi``. See :ref:`wasm-availability` for " "more information." msgstr "" #: library/multiprocessing.rst:14 msgid "Introduction" msgstr "Introduction" #: library/multiprocessing.rst:16 msgid "" ":mod:`multiprocessing` is a package that supports spawning processes using " "an API similar to the :mod:`threading` module. The :mod:`multiprocessing` " "package offers both local and remote concurrency, effectively side-stepping " "the :term:`Global Interpreter Lock ` by using " "subprocesses instead of threads. Due to this, the :mod:`multiprocessing` " "module allows the programmer to fully leverage multiple processors on a " "given machine. It runs on both Unix and Windows." msgstr "" ":mod:`multiprocessing` est un paquet qui permet l'instanciation de processus " "via la même API que le module :mod:`threading`. Le paquet :mod:" "`multiprocessing` permet la programmation concurrente sur une même machine " "ou entre machines. Il permet de contourner les problèmes du :term:`verrou " "global de l'interpréteur (GIL) ` en " "utilisant des processus plutôt que des fils d'exécution. Ainsi, le module :" "mod:`multiprocessing` permet au développeur d'exploiter au mieux tous les " "processeurs d'une machine. Il tourne à la fois sur les systèmes Unix et " "Windows." #: library/multiprocessing.rst:25 msgid "" "The :mod:`multiprocessing` module also introduces APIs which do not have " "analogs in the :mod:`threading` module. A prime example of this is the :" "class:`~multiprocessing.pool.Pool` object which offers a convenient means of " "parallelizing the execution of a function across multiple input values, " "distributing the input data across processes (data parallelism). The " "following example demonstrates the common practice of defining such " "functions in a module so that child processes can successfully import that " "module. This basic example of data parallelism using :class:" "`~multiprocessing.pool.Pool`, ::" msgstr "" "Le module :mod:`multiprocessing` introduit aussi des API sans analogues dans " "le module :mod:`threading`. Un exemple est l'objet :class:`~multiprocessing." "pool.Pool` qui offre un moyen simple de paralléliser l'exécution d'une " "fonction sur plusieurs valeurs d'entrée, en distribuant ces valeurs entre " "les processus (parallélisme de données). L'exemple suivant présente la " "manière classique de définir une telle fonction dans un module afin que les " "processus fils puissent importer ce module avec succès. Cet exemple basique " "de parallélisme de données, utilisant :class:`~multiprocessing.pool.Pool`, ::" #: library/multiprocessing.rst:43 msgid "will print to standard output ::" msgstr "affiche sur la sortie standard ::" #: library/multiprocessing.rst:50 msgid "" ":class:`concurrent.futures.ProcessPoolExecutor` offers a higher level " "interface to push tasks to a background process without blocking execution " "of the calling process. Compared to using the :class:`~multiprocessing.pool." "Pool` interface directly, the :mod:`concurrent.futures` API more readily " "allows the submission of work to the underlying process pool to be separated " "from waiting for the results." msgstr "" #: library/multiprocessing.rst:59 msgid "The :class:`Process` class" msgstr "La classe :class:`Process`" #: library/multiprocessing.rst:61 msgid "" "In :mod:`multiprocessing`, processes are spawned by creating a :class:" "`Process` object and then calling its :meth:`~Process.start` method. :class:" "`Process` follows the API of :class:`threading.Thread`. A trivial example " "of a multiprocess program is ::" 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 ::" #: library/multiprocessing.rst:76 msgid "" "To show the individual process IDs involved, here is an expanded example::" msgstr "" "Voici un exemple plus étoffé qui affiche les identifiants des processus " "créés ::" #: library/multiprocessing.rst:97 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 dans la " "section :ref:`multiprocessing-programming`." #: library/multiprocessing.rst:103 msgid "Contexts and start methods" msgstr "Contextes et méthodes de démarrage" #: library/multiprocessing.rst:107 msgid "" "Depending on the platform, :mod:`multiprocessing` supports three ways to " "start a process. These *start methods* are" msgstr "" "Selon la plateforme, :mod:`multiprocessing` gère trois manières de démarrer " "un processus. Ces *méthodes de démarrage* sont" #: library/multiprocessing.rst:118 msgid "*spawn*" msgstr "*spawn*" #: library/multiprocessing.rst:111 #, fuzzy msgid "" "The parent process starts a fresh Python interpreter process. The child " "process will only inherit those resources necessary to run the process " "object's :meth:`~Process.run` method. In particular, unnecessary file " "descriptors and handles from the parent process will not be inherited. " "Starting a process using this method is rather slow compared to using *fork* " "or *forkserver*." 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*." #: library/multiprocessing.rst:118 msgid "Available on Unix and Windows. The default on Windows and macOS." msgstr "Disponible sur Unix et Windows. Par défaut sur Windows et macOS." #: library/multiprocessing.rst:127 msgid "*fork*" msgstr "*fork*" #: library/multiprocessing.rst:121 msgid "" "The parent process uses :func:`os.fork` to fork the Python interpreter. The " "child process, when it begins, is effectively identical to the parent " "process. All resources of the parent are inherited by the child process. " "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é*." #: library/multiprocessing.rst:127 msgid "Available on Unix only. The default on Unix." msgstr "Disponible uniquement sous Unix. Par défaut sous Unix." #: library/multiprocessing.rst:138 msgid "*forkserver*" msgstr "*forkserver*" #: library/multiprocessing.rst:130 msgid "" "When the program starts and selects the *forkserver* start method, a server " "process is started. From then on, whenever a new process is needed, the " "parent process connects to the server and requests that it fork a new " "process. The fork server process is single threaded so it is safe for it to " "use :func:`os.fork`. No unnecessary resources are inherited." 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." #: library/multiprocessing.rst:137 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." #: library/multiprocessing.rst:142 library/multiprocessing.rst:1070 msgid "" "On macOS, the *spawn* start method is now the default. The *fork* start " "method should be considered unsafe as it can lead to crashes of the " "subprocess. See :issue:`33725`." msgstr "" "sur macOS, la méthode de démarrage *spawn* est maintenant la méthode par " "défaut. La méthode de démarrage *fork* doit être considérée comme dangereuse " "car elle peut entraîner des plantages du sous-processus. Voir :issue:`33725`." #: library/multiprocessing.rst:146 #, fuzzy msgid "" "*spawn* added on all Unix platforms, and *forkserver* added for some Unix " "platforms. Child processes no longer inherit all of the parents inheritable " "handles on Windows." msgstr "" "ajout de *spawn* à toutes les plateformes Unix et ajout de *forkserver* à " "certaines plateformes Unix. Les processus fils n'héritent plus de tous les " "descripteurs héritables du parent sous Windows." #: library/multiprocessing.rst:152 msgid "" "On Unix using the *spawn* or *forkserver* start methods will also start a " "*resource tracker* process which tracks the unlinked named system resources " "(such as named semaphores or :class:`~multiprocessing.shared_memory." "SharedMemory` objects) created by processes of the program. When all " "processes have exited the resource tracker unlinks any remaining tracked " "object. Usually there should be none, but if a process was killed by a " "signal there may be some \"leaked\" resources. (Neither leaked semaphores " "nor shared memory segments will be automatically unlinked until the next " "reboot. This is problematic for both objects because the system allows only " "a limited number of named semaphores, and shared memory segments occupy some " "space in the main memory.)" msgstr "" "Sous Unix, utiliser les méthodes de démarrage *spawn* ou *forkserver* " "démarre aussi un processus de *suivi de ressources* qui détecte les " "ressources systèmes non-libérées (comme des sémaphores nommés ou des objets :" "class:`~multiprocessing.shared_memory.SharedMemory`) créés par les processus " "du programme. Quand tous les processus sont terminés, le traqueur de " "ressources libère tous les objets restants. Normalement, il ne devrait pas y " "en avoir, mais si un processus a été tué par un signal, certaines ressources " "peuvent avoir été « perdues ». Ni les sémaphores ni les blocs de mémoire " "partagée ne sont libérés avant le prochain redémarrage. C'est problématique " "dans les deux cas car le système n'autorise qu'un nombre limité de " "sémaphores et parce que les blocs de mémoire partagée prennent de la place " "dans la mémoire principale." #: library/multiprocessing.rst:165 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 ::" #: library/multiprocessing.rst:182 msgid "" ":func:`set_start_method` should not be used more than once in the program." msgstr "" ":func:`set_start_method` ne doit pas être utilisée plus d'une fois dans le " "programme." #: library/multiprocessing.rst:185 msgid "" "Alternatively, you can use :func:`get_context` to obtain a context object. " "Context objects have the same API as the multiprocessing module, and allow " "one to use multiple start methods in the same program. ::" 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. ::" #: library/multiprocessing.rst:203 msgid "" "Note that objects related to one context may not be compatible with " "processes for a different context. In particular, locks created using the " "*fork* context cannot be passed to processes started using the *spawn* or " "*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*." #: library/multiprocessing.rst:208 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." #: library/multiprocessing.rst:214 msgid "" "The ``'spawn'`` and ``'forkserver'`` start methods cannot currently be used " "with \"frozen\" executables (i.e., binaries produced by packages like " "**PyInstaller** and **cx_Freeze**) on Unix. The ``'fork'`` start method does " "work." msgstr "" "Les méthodes de démarrage ``’spawn’`` et ``’forkserver’`` ne peuvent pas " "être utilisées avec des exécutables « figés » (c'est-à-dire des binaires " "produits par des paquets comme **PyInstaller** et **cx_Freeze**) sur Unix. " "Seule la méthode de démarrage ``’fork’`` fonctionne." #: library/multiprocessing.rst:221 msgid "Exchanging objects between processes" msgstr "Échange d'objets entre les processus" #: library/multiprocessing.rst:223 msgid "" ":mod:`multiprocessing` supports two types of communication channel between " "processes:" msgstr "" ":mod:`multiprocessing` gère deux types de canaux de communication entre les " "processus :" #: library/multiprocessing.rst:226 msgid "**Queues**" msgstr "**Files** (*queues*)" #: library/multiprocessing.rst:228 msgid "" "The :class:`Queue` class is a near clone of :class:`queue.Queue`. For " "example::" msgstr "" "La classe :class:`Queue` est un clone assez proche de :class:`queue.Queue`. " "Par exemple ::" #: library/multiprocessing.rst:243 msgid "Queues are thread and process safe." msgstr "" "Les files peuvent être utilisées par plusieurs fils d'exécution ou processus." #: library/multiprocessing.rst:245 msgid "**Pipes**" msgstr "**Tubes** (*pipes*)" #: library/multiprocessing.rst:247 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 duplex (à double sens). Par exemple ::" #: library/multiprocessing.rst:263 msgid "" "The two connection objects returned by :func:`Pipe` represent the two ends " "of the pipe. Each connection object has :meth:`~Connection.send` and :meth:" "`~Connection.recv` methods (among others). Note that data in a pipe may " "become corrupted if two processes (or threads) try to read from or write to " "the *same* end of the pipe at the same time. Of course there is no risk of " "corruption from processes using different ends of the pipe at the same time." msgstr "" "Les deux objets de connexion renvoyés par :func:`Pipe` représentent les deux " "extrémités d'un tube. Chaque objet de connexion possède (entre autres) des " "méthodes :meth:`~Connection.send` et :meth:`~Connection.recv`. Notez que les " "données d'un tube peuvent être corrompues si deux processus (ou fils " "d'exécution) essaient de lire ou d'écrire sur la même extrémité du tube en " "même temps. Bien évidemment, deux processus peuvent utiliser les deux " "extrémités différentes en même temps sans risque de corruption." #: library/multiprocessing.rst:273 msgid "Synchronization between processes" msgstr "Synchronisation entre processus" #: library/multiprocessing.rst:275 msgid "" ":mod:`multiprocessing` contains equivalents of all the synchronization " "primitives from :mod:`threading`. For instance one can use a lock to ensure " "that only one process prints to standard output at a time::" 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 ::" #: library/multiprocessing.rst:294 msgid "" "Without using the lock output from the different processes is liable to get " "all mixed up." msgstr "" "Sans le verrou, les sorties des différents processus risquent d'être " "mélangées." #: library/multiprocessing.rst:299 msgid "Sharing state between processes" msgstr "Partager un état entre les processus" #: library/multiprocessing.rst:301 msgid "" "As mentioned above, when doing concurrent programming it is usually best to " "avoid using shared state as far as possible. This is particularly true when " "using multiple processes." 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." #: library/multiprocessing.rst:305 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." #: library/multiprocessing.rst:308 msgid "**Shared memory**" msgstr "**Mémoire partagée**" #: library/multiprocessing.rst:310 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 ::" #: library/multiprocessing.rst:331 library/multiprocessing.rst:377 msgid "will print ::" msgstr "affiche ::" #: library/multiprocessing.rst:336 msgid "" "The ``'d'`` and ``'i'`` arguments used when creating ``num`` and ``arr`` are " "typecodes of the kind used by the :mod:`array` module: ``'d'`` indicates a " "double precision float and ``'i'`` indicates a signed integer. These shared " "objects will be process and thread-safe." msgstr "" "Les arguments ``'d'`` et ``'i'`` utilisés à la création des ``num`` et " "``arr`` sont des codes de types identiques à ceux du module :mod:`array` : " "``'d'`` indique un flottant double-précision et ``'i'`` indique un entier " "signé. Ces objets peuvent être partagés sans problème entre processus ou " "fils d’exécution." #: library/multiprocessing.rst:341 msgid "" "For more flexibility in using shared memory one can use the :mod:" "`multiprocessing.sharedctypes` module which supports the creation of " "arbitrary ctypes objects allocated from shared memory." 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." #: library/multiprocessing.rst:345 msgid "**Server process**" msgstr "**Processus serveur**" #: library/multiprocessing.rst:347 msgid "" "A manager object returned by :func:`Manager` controls a server process which " "holds Python objects and allows other processes to manipulate them using " "proxies." 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." #: library/multiprocessing.rst:351 msgid "" "A manager returned by :func:`Manager` will support types :class:`list`, :" "class:`dict`, :class:`~managers.Namespace`, :class:`Lock`, :class:`RLock`, :" "class:`Semaphore`, :class:`BoundedSemaphore`, :class:`Condition`, :class:" "`Event`, :class:`Barrier`, :class:`Queue`, :class:`Value` and :class:" "`Array`. For example, ::" msgstr "" "Un gestionnaire renvoyé par :func:`Manager` prend en charge les types :class:" "`list`, :class:`dict`, :class:`~managers.Namespace`, :class:`Lock`, :class:" "`RLock`, :class:`Semaphore`, :class:`BoundedSemaphore`, :class:`Condition`, :" "class:`Event`, :class:`Barrier`, :class:`Queue`, :class:`Value` et :class:" "`Array`. Par exemple, ::" #: library/multiprocessing.rst:382 msgid "" "Server process managers are more flexible than using shared memory objects " "because they can be made to support arbitrary object types. Also, a single " "manager can be shared by processes on different computers over a network. " "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." #: library/multiprocessing.rst:389 msgid "Using a pool of workers" msgstr "Utiliser un pool de *workers*" #: library/multiprocessing.rst:391 msgid "" "The :class:`~multiprocessing.pool.Pool` class represents a pool of worker " "processes. It has methods which allows tasks to be offloaded to the worker " "processes in a few different ways." msgstr "" "La classe :class:`~multiprocessing.pool.Pool` représente un pool de " "processus de travail. Elle possède des méthodes qui permettent aux tâches " "d'être déchargées vers les processus de travail de différentes manières." #: library/multiprocessing.rst:395 msgid "For example::" msgstr "Par exemple ::" #: library/multiprocessing.rst:439 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'un pool ne doivent être utilisées que par le " "processus qui l'a créée." #: library/multiprocessing.rst:444 msgid "" "Functionality within this package requires that the ``__main__`` module be " "importable by the children. This is covered in :ref:`multiprocessing-" "programming` however it is worth pointing out here. This means that some " "examples, such as the :class:`multiprocessing.pool.Pool` examples will not " "work in the interactive interpreter. For example::" 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 ::" #: library/multiprocessing.rst:467 msgid "" "(If you try this it will actually output three full tracebacks interleaved " "in a semi-random fashion, and then you may have to stop the parent process " "somehow.)" msgstr "" "Si vous essayez ce code, il affichera trois traces d'appels complètes " "entrelacées de manière semi-aléatoire, et vous devrez vous débrouiller pour " "arrêter le processus maître." #: library/multiprocessing.rst:473 msgid "Reference" msgstr "Référence" #: library/multiprocessing.rst:475 msgid "" "The :mod:`multiprocessing` package mostly replicates the API of the :mod:" "`threading` module." msgstr "" "Le paquet :mod:`multiprocessing` reproduit en grande partie l'API du module :" "mod:`threading`." #: library/multiprocessing.rst:480 msgid ":class:`Process` and exceptions" msgstr ":class:`Process` et exceptions" #: library/multiprocessing.rst:485 msgid "" "Process objects represent activity that is run in a separate process. The :" "class:`Process` class has equivalents of all the methods of :class:" "`threading.Thread`." 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`." #: library/multiprocessing.rst:489 msgid "" "The constructor should always be called with keyword arguments. *group* " "should always be ``None``; it exists solely for compatibility with :class:" "`threading.Thread`. *target* is the callable object to be invoked by the :" "meth:`run()` method. It defaults to ``None``, meaning nothing is called. " "*name* is the process name (see :attr:`name` for more details). *args* is " "the argument tuple for the target invocation. *kwargs* is a dictionary of " "keyword arguments for the target invocation. If provided, the keyword-only " "*daemon* argument sets the process :attr:`daemon` flag to ``True`` or " "``False``. If ``None`` (the default), this flag will be inherited from the " "creating process." msgstr "" "Le constructeur doit toujours être appelé avec des arguments nommés. *group* " "doit toujours être ``None`` ; il existe uniquement pour la compatibilité " "avec :class:`threading.Thread`. *target* est l'objet appelable qui est " "invoqué par la méthode :meth:`run(). Il vaut ``None`` par défaut, signifiant " "que rien n'est appelé. *name* est le nom du processus (voir :attr:`name` " "pour plus de détails). *args* est le *n*-uplet d'arguments pour l'invocation " "de la cible. *kwargs* est le dictionnaire des arguments nommés pour " "l'invocation de la cible. S'il est fourni, l'argument nommé *daemon* met " "l'option :attr:`daemon` du processus à ``True`` ou ``False``. S'il est " "``None`` (par défaut), l'option est héritée par le processus créateur." #: library/multiprocessing.rst:500 msgid "" "By default, no arguments are passed to *target*. The *args* argument, which " "defaults to ``()``, can be used to specify a list or tuple of the arguments " "to pass to *target*." msgstr "" #: library/multiprocessing.rst:504 msgid "" "If a subclass overrides the constructor, it must make sure it invokes the " "base class constructor (:meth:`Process.__init__`) before doing anything else " "to the process." 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." #: library/multiprocessing.rst:508 msgid "Added the *daemon* argument." msgstr "Ajout de l'argument *daemon*." #: library/multiprocessing.rst:513 msgid "Method representing the process's activity." msgstr "Méthode représentant l'activité du processus." #: library/multiprocessing.rst:515 msgid "" "You may override this method in a subclass. The standard :meth:`run` method " "invokes the callable object passed to the object's constructor as the target " "argument, if any, with sequential and keyword arguments taken from the " "*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*." #: library/multiprocessing.rst:520 msgid "" "Using a list or tuple as the *args* argument passed to :class:`Process` " "achieves the same effect." msgstr "" #: library/multiprocessing.rst:523 #, fuzzy msgid "Example::" msgstr "Exemples ::" #: library/multiprocessing.rst:535 msgid "Start the process's activity." msgstr "Démarre l'activité du processus." #: library/multiprocessing.rst:537 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é." #: library/multiprocessing.rst:542 msgid "" "If the optional argument *timeout* is ``None`` (the default), the method " "blocks until the process whose :meth:`join` method is called terminates. If " "*timeout* is a positive number, it blocks at most *timeout* seconds. Note " "that the method returns ``None`` if its process terminates or if the method " "times out. Check the process's :attr:`exitcode` to determine if it " "terminated." 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é." #: library/multiprocessing.rst:549 msgid "A process can be joined many times." msgstr "*join* peut être appelée plusieurs fois sur un même processus." #: library/multiprocessing.rst:551 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é." #: library/multiprocessing.rst:556 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." #: library/multiprocessing.rst:560 msgid "" "The initial name is set by the constructor. If no explicit name is provided " "to the constructor, a name of the form 'Process-N\\ :sub:`1`:N\\ :sub:" "`2`:...:N\\ :sub:`k`' is constructed, where each N\\ :sub:`k` is the N-th " "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\\ :" "sup:`e` fils de son parent." #: library/multiprocessing.rst:567 msgid "Return whether the process is alive." msgstr "Renvoie vrai si le processus est en vie, faux sinon." #: library/multiprocessing.rst:569 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." #: library/multiprocessing.rst:574 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." #: library/multiprocessing.rst:577 msgid "The initial value is inherited from the creating process." msgstr "La valeur initiale est héritée par le processus créateur." #: library/multiprocessing.rst:579 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 fils " "*daemon*." #: library/multiprocessing.rst:582 msgid "" "Note that a daemonic process is not allowed to create child processes. " "Otherwise a daemonic process would leave its children orphaned if it gets " "terminated when its parent process exits. Additionally, these are **not** " "Unix daemons or services, they are normal processes that will be terminated " "(and not joined) if non-daemonic processes have exited." msgstr "" "Notez qu'un processus *daemon* n'est pas autorisé à créer des processus " "fils. Sinon un processus *daemon* laisserait ses fils orphelins lorsqu'il se " "termine par la fermeture de son parent. De plus, ce **ne sont pas** des " "*daemons* ou services Unix, ce sont des processus normaux qui seront " "terminés (et non attendus) si un processus non *daemon* se ferme." #: library/multiprocessing.rst:588 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 :" #: library/multiprocessing.rst:593 msgid "" "Return the process ID. Before the process is spawned, this will be ``None``." msgstr "" "Renvoie l'ID du processus. Avant que le processus ne soit lancé, la valeur " "est ``None``." #: library/multiprocessing.rst:598 #, fuzzy msgid "" "The child's exit code. This will be ``None`` if the process has not yet " "terminated." msgstr "" "Le code de retour du fils. La valeur est ``None`` si le processus ne s'est " "pas encore terminé. Une valeur négative *-N* indique que le fils a été " "terminé par un signal *N*." #: library/multiprocessing.rst:601 msgid "" "If the child's :meth:`run` method returned normally, the exit code will be " "0. If it terminated via :func:`sys.exit` with an integer argument *N*, the " "exit code will be *N*." msgstr "" #: library/multiprocessing.rst:605 msgid "" "If the child terminated due to an exception not caught within :meth:`run`, " "the exit code will be 1. If it was terminated by signal *N*, the exit code " "will be the negative value *-N*." msgstr "" #: library/multiprocessing.rst:611 msgid "The process's authentication key (a byte string)." msgstr "La clé d'authentification du processus (une chaîne d'octets)." #: library/multiprocessing.rst:613 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`." #: library/multiprocessing.rst:616 msgid "" "When a :class:`Process` object is created, it will inherit the " "authentication key of its parent process, although this may be changed by " "setting :attr:`authkey` to another byte string." 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." #: library/multiprocessing.rst:620 msgid "See :ref:`multiprocessing-auth-keys`." msgstr "Voir :ref:`multiprocessing-auth-keys`." #: library/multiprocessing.rst:624 msgid "" "A numeric handle of a system object which will become \"ready\" when the " "process ends." msgstr "" "Un identifiant numérique de l'objet système qui devient « prêt » quand le " "processus se termine." #: library/multiprocessing.rst:627 msgid "" "You can use this value if you want to wait on several events at once using :" "func:`multiprocessing.connection.wait`. Otherwise calling :meth:`join()` is " "simpler." 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." #: library/multiprocessing.rst:631 msgid "" "On Windows, this is an OS handle usable with the ``WaitForSingleObject`` and " "``WaitForMultipleObjects`` family of API calls. On Unix, this is a file " "descriptor usable with primitives from the :mod:`select` module." msgstr "" "Sous Windows, c'est un mécanisme système utilisable avec les familles " "d'appels API ``WaitForSingleObject`` et ``WaitForMultipleObjects``. Sous " "Unix, c'est un descripteur de fichier utilisable avec les primitives sur " "module :mod:`select`." #: library/multiprocessing.rst:639 msgid "" "Terminate the process. On Unix this is done using the ``SIGTERM`` signal; " "on Windows :c:func:`TerminateProcess` is used. Note that exit handlers and " "finally clauses, etc., will not be executed." 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." #: library/multiprocessing.rst:643 msgid "" "Note that descendant processes of the process will *not* be terminated -- " "they will simply become orphaned." msgstr "" "Notez que les descendants du processus ne sont *pas* terminés – ils " "deviendront simplement orphelins." #: library/multiprocessing.rst:648 msgid "" "If this method is used when the associated process is using a pipe or queue " "then the pipe or queue is liable to become corrupted and may become unusable " "by other process. Similarly, if the process has acquired a lock or " "semaphore etc. then terminating it is liable to cause other processes to " "deadlock." msgstr "" "Si cette méthode est utilisée quand le processus associé utilise un tube ou " "une file, alors le tube ou la file sont susceptibles d'être corrompus et " "peuvent devenir inutilisables par les autres processus. De façon similaire, " "si le processus a acquis un verrou, un sémaphore ou autre, alors le terminer " "est susceptible de provoquer des blocages dans les autres processus." #: library/multiprocessing.rst:656 msgid "Same as :meth:`terminate()` but using the ``SIGKILL`` signal on Unix." msgstr "" "Identique à :meth:`terminate()` mais utilisant le signal ``SIGKILL`` sous " "Unix." #: library/multiprocessing.rst:662 msgid "" "Close the :class:`Process` object, releasing all resources associated with " "it. :exc:`ValueError` is raised if the underlying process is still " "running. Once :meth:`close` returns successfully, most other methods and " "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`." #: library/multiprocessing.rst:670 msgid "" "Note that the :meth:`start`, :meth:`join`, :meth:`is_alive`, :meth:" "`terminate` and :attr:`exitcode` methods should only be called by the " "process that created the process object." msgstr "" "Notez que les méthodes :meth:`start`, :meth:`join`, :meth:`is_alive`, :meth:" "`terminate` et :attr:`exitcode` ne doivent être appelées que par le " "processus ayant créé l'objet *process*." #: library/multiprocessing.rst:674 msgid "Example usage of some of the methods of :class:`Process`:" msgstr "Exemple d'utilisation de quelques méthodes de :class:`Process` :" #: library/multiprocessing.rst:694 msgid "The base class of all :mod:`multiprocessing` exceptions." msgstr "La classe de base de toutes les exceptions de :mod:`multiprocessing`." #: library/multiprocessing.rst:698 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." #: library/multiprocessing.rst:701 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." #: library/multiprocessing.rst:706 msgid "Raised when there is an authentication error." msgstr "Levée quand il y a une erreur d'authentification." #: library/multiprocessing.rst:710 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." #: library/multiprocessing.rst:713 msgid "Pipes and Queues" msgstr "Tubes (*pipes*) et files (*queues*)" #: library/multiprocessing.rst:715 msgid "" "When using multiple processes, one generally uses message passing for " "communication between processes and avoids having to use any synchronization " "primitives like locks." msgstr "" "Quand plusieurs processus travaillent ensemble, il est souvent nécessaire de " "les faire communiquer entre eux pour éviter d'avoir à utiliser des " "primitives de synchronisation comme les verrous." #: library/multiprocessing.rst:719 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 file (qui autorise de plusieurs " "producteurs et consommateurs)." #: library/multiprocessing.rst:722 msgid "" "The :class:`Queue`, :class:`SimpleQueue` and :class:`JoinableQueue` types " "are multi-producer, multi-consumer :abbr:`FIFO (first-in, first-out)` queues " "modelled on the :class:`queue.Queue` class in the standard library. They " "differ in that :class:`Queue` lacks the :meth:`~queue.Queue.task_done` and :" "meth:`~queue.Queue.join` methods introduced into Python 2.5's :class:`queue." "Queue` class." msgstr "" "Les types :class:`Queue`, :class:`SimpleQueue` et :class:`JoinableQueue` " "sont des files :abbr:`FIFO (first-in, first-out)` multi-producteurs et multi-" "consommateurs modelées sur la classe :class:`queue.Queue` de la bibliothèque " "standard. Elles diffèrent par l'absence dans :class:`Queue` des méthodes :" "meth:`~queue.Queue.task_done` et :meth:`~queue.Queue.join` introduites dans " "la classe :class:`queue.Queue` par Python 2.5." #: library/multiprocessing.rst:729 msgid "" "If you use :class:`JoinableQueue` then you **must** call :meth:" "`JoinableQueue.task_done` for each task removed from the queue or else the " "semaphore used to count the number of unfinished tasks may eventually " "overflow, raising an exception." msgstr "" "Si vous utilisez :class:`JoinableQueue` alors vous **devez** appeler :meth:" "`JoinableQueue.task_done` pour chaque tâche retirée de la file, sans quoi le " "sémaphore utilisé pour compter le nombre de tâches non accomplies pourra " "éventuellement déborder, levant une exception." #: library/multiprocessing.rst:734 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 file partagée en utilisant un objet " "gestionnaire – voir :ref:`multiprocessing-managers`." #: library/multiprocessing.rst:739 msgid "" ":mod:`multiprocessing` uses the usual :exc:`queue.Empty` and :exc:`queue." "Full` exceptions to signal a timeout. They are not available in the :mod:" "`multiprocessing` namespace so you need to import them from :mod:`queue`." msgstr "" ":mod:`multiprocessing` utilise les exceptions habituelles :exc:`queue.Empty` " "et :exc:`queue.Full` pour signaler un dépassement du temps maximal autorisé. " "Elles ne sont pas disponibles dans l'espace de nommage :mod:" "`multiprocessing` donc vous devez les importer depuis le module :mod:`queue`." #: library/multiprocessing.rst:746 msgid "" "When an object is put on a queue, the object is pickled and a background " "thread later flushes the pickled data to an underlying pipe. This has some " "consequences which are a little surprising, but should not cause any " "practical difficulties -- if they really bother you then you can instead use " "a queue created with a :ref:`manager `." msgstr "" "Quand un objet est placé dans une file, l'objet est sérialisé par *pickle* " "et un fil d'exécution en arrière-plan transmettra ensuite les données " "sérialisées sur un tube sous-jacent. Cela a certaines conséquences qui " "peuvent être un peu surprenantes, mais ne devrait causer aucune difficulté " "pratique — si elles vous embêtent vraiment, alors vous pouvez à la place " "utiliser une file créée avec un :ref:`manager `." #: library/multiprocessing.rst:753 msgid "" "After putting an object on an empty queue there may be an infinitesimal " "delay before the queue's :meth:`~Queue.empty` method returns :const:`False` " "and :meth:`~Queue.get_nowait` can return without raising :exc:`queue.Empty`." msgstr "" "Après avoir placé un objet dans une file vide il peut y avoir un délai " "infinitésimal avant que la méthode :meth:`~Queue.empty` de la file renvoie :" "const:`False` et que :meth:`~Queue.get_nowait` renvoie une valeur sans lever " "de :exc:`queue.Empty`." #: library/multiprocessing.rst:758 msgid "" "If multiple processes are enqueuing objects, it is possible for the objects " "to be received at the other end out-of-order. However, objects enqueued by " "the same process will always be in the expected order with respect to each " "other." msgstr "" "Si plusieurs processus placent des objets dans la file, il est possible pour " "les objets d'être reçus de l'autre côté dans le désordre. Cependant, les " "objets placés par un même processus seront toujours récupérés dans l'ordre " "d'insertion." #: library/multiprocessing.rst:765 msgid "" "If a process is killed using :meth:`Process.terminate` or :func:`os.kill` " "while it is trying to use a :class:`Queue`, then the data in the queue is " "likely to become corrupted. This may cause any other process to get an " "exception when it tries to use the queue later on." msgstr "" "Si un processus est tué à l'aide de :meth:`Process.terminate` ou :func:`os." "kill` pendant qu'il tente d'utiliser une :class:`Queue`, alors les données " "de la file peuvent être corrompues. Cela peut par la suite causer des levées " "d'exceptions dans les autres processus quand ils tenteront d'utiliser la " "file." #: library/multiprocessing.rst:772 msgid "" "As mentioned above, if a child process has put items on a queue (and it has " "not used :meth:`JoinableQueue.cancel_join_thread `), then that process will not terminate until all " "buffered items have been flushed to the pipe." msgstr "" "Comme mentionné plus haut, si un processus fils a placé des éléments dans la " "file (et qu'il n'a pas utilisé :meth:`JoinableQueue.cancel_join_thread " "`), alors le processus ne se " "terminera pas tant que les éléments placés dans le tampon n'auront pas été " "transmis au tube." #: library/multiprocessing.rst:777 msgid "" "This means that if you try joining that process you may get a deadlock " "unless you are sure that all items which have been put on the queue have " "been consumed. Similarly, if the child process is non-daemonic then the " "parent process may hang on exit when it tries to join all its non-daemonic " "children." msgstr "" "Cela signifie que si vous essayez d'attendre ce processus vous pouvez " "obtenir un interblocage, à moins que vous ne soyez sûr que tous les éléments " "placés dans la file ont été consommés. De même, si le processus fils n'est " "pas un *daemon* alors le processus parent pourrait bloquer à la fermeture " "quand il tentera d'attendre tous ses fils non *daemons*." #: library/multiprocessing.rst:782 msgid "" "Note that a queue created using a manager does not have this issue. See :" "ref:`multiprocessing-programming`." msgstr "" "Notez que la file créée à l'aide d'un gestionnaire n'a pas ce problème. " "Voir :ref:`multiprocessing-programming`." #: library/multiprocessing.rst:785 msgid "" "For an example of the usage of queues for interprocess communication see :" "ref:`multiprocessing-examples`." msgstr "" "Pour un exemple d'utilisation de files pour de la communication entre les " "processus, voir :ref:`multiprocessing-examples`." #: library/multiprocessing.rst:791 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 extrémités d'un tube." #: library/multiprocessing.rst:795 msgid "" "If *duplex* is ``True`` (the default) then the pipe is bidirectional. If " "*duplex* is ``False`` then the pipe is unidirectional: ``conn1`` can only be " "used for receiving messages and ``conn2`` can only be used for sending " "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." #: library/multiprocessing.rst:803 msgid "" "Returns a process shared queue implemented using a pipe and a few locks/" "semaphores. When a process first puts an item on the queue a feeder thread " "is started which transfers objects from a buffer into the pipe." msgstr "" "Renvoie une file partagée entre les processus utilisant un tube et quelques " "verrous / sémaphores. Quand un processus place initialement un élément sur " "la file, un fil d'exécution *chargeur* est démarré pour transférer les " "objets du tampon vers le tube." #: library/multiprocessing.rst:807 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*." #: library/multiprocessing.rst:810 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`." #: library/multiprocessing.rst:815 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 file. Ce nombre n'est pas fiable en " "raison des problématiques de *multithreading* et *multiprocessing*." #: library/multiprocessing.rst:818 msgid "" "Note that this may raise :exc:`NotImplementedError` on Unix platforms like " "macOS where ``sem_getvalue()`` is not implemented." msgstr "" "Notez que cela peut lever une :exc:`NotImplementedError` sous certaines " "plateformes Unix comme macOS où ``sem_getvalue()`` n'est pas implémentée." #: library/multiprocessing.rst:823 msgid "" "Return ``True`` if the queue is empty, ``False`` otherwise. Because of " "multithreading/multiprocessing semantics, this is not reliable." msgstr "" "Renvoie ``True`` si la file est vide, ``False`` sinon. Cette valeur n'est " "pas fiable en raison des problématiques de *multithreading* et " "*multiprocessing*." #: library/multiprocessing.rst:828 msgid "" "Return ``True`` if the queue is full, ``False`` otherwise. Because of " "multithreading/multiprocessing semantics, this is not reliable." msgstr "" "Renvoie ``True`` si la file est pleine, ``False`` sinon. Cette valeur n'est " "pas fiable en raison des problématiques de *multithreading* et " "*multiprocessing*." #: library/multiprocessing.rst:833 msgid "" "Put obj into the queue. If the optional argument *block* is ``True`` (the " "default) and *timeout* is ``None`` (the default), block if necessary until a " "free slot is available. If *timeout* is a positive number, it blocks at " "most *timeout* seconds and raises the :exc:`queue.Full` exception if no free " "slot was available within that time. Otherwise (*block* is ``False``), put " "an item on the queue if a free slot is immediately available, else raise " "the :exc:`queue.Full` exception (*timeout* is ignored in that case)." msgstr "" "Place *obj* dans la file. Si l'argument optionnel *block* vaut ``True`` (par " "défaut) est que *timeout* est ``None`` (par défaut), bloque jusqu'à ce " "qu'une place libre soit disponible. Si *timeout* est un nombre positif, la " "méthode bloquera au maximum *timeout* secondes et lève une exception :exc:" "`queue.Full` si aucune place libre n'a été trouvée dans le temps imparti. " "Autrement (*block* vaut ``False``), place un élément dans la file si une " "place libre est immédiatement disponible, ou lève une exception :exc:`queue." "Full` dans le cas contraire (*timeout* est ignoré dans ce cas)." #: library/multiprocessing.rst:842 msgid "" "If the queue is closed, :exc:`ValueError` is raised instead of :exc:" "`AssertionError`." msgstr "" "si la file a été marquée comme fermée, une :exc:`ValueError` est levée. " "Auparavant, une :exc:`AssertionError` était levée." #: library/multiprocessing.rst:848 msgid "Equivalent to ``put(obj, False)``." msgstr "Équivalent à ``put(obj, False)``." #: library/multiprocessing.rst:852 msgid "" "Remove and return an item from the queue. If optional args *block* is " "``True`` (the default) and *timeout* is ``None`` (the default), block if " "necessary until an item is available. If *timeout* is a positive number, it " "blocks at most *timeout* seconds and raises the :exc:`queue.Empty` exception " "if no item was available within that time. Otherwise (block is ``False``), " "return an item if one is immediately available, else raise the :exc:`queue." "Empty` exception (*timeout* is ignored in that case)." msgstr "" "Retire et renvoie un élément de la file. Si l'argument optionnel *block* " "vaut ``True`` (par défaut) et que *timeout* est ``None`` (par défaut), " "bloque jusqu'à ce qu'un élément soit disponible. Si *timeout* (le délai " "maximal autorisé) est un nombre positif, la méthode bloque au maximum " "*timeout* secondes et lève une exception :exc:`queue.Empty` si aucun élément " "n'est disponible dans le temps imparti. Autrement (*block* vaut ``False``), " "renvoie un élément s'il est immédiatement disponible, ou lève une exception :" "exc:`queue.Empty` dans le cas contraire (*timeout* est ignoré dans ce cas)." #: library/multiprocessing.rst:860 msgid "" "If the queue is closed, :exc:`ValueError` is raised instead of :exc:" "`OSError`." msgstr "" "si la file a été marquée comme terminée, une :exc:`ValueError` est levée. " "Auparavant, une :exc:`OSError`. était levée." #: library/multiprocessing.rst:866 msgid "Equivalent to ``get(False)``." msgstr "Équivalent à ``get(False)``." #: library/multiprocessing.rst:868 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 :" #: library/multiprocessing.rst:874 msgid "" "Indicate that no more data will be put on this queue by the current " "process. The background thread will quit once it has flushed all buffered " "data to the pipe. This is called automatically when the queue is garbage " "collected." msgstr "" "Indique que plus aucune donnée ne peut être placée sur la file par le " "processus courant. Le fil d'exécution en arrière-plan se terminera quand il " "aura transféré toutes les données du tampon vers le tube. Elle est appelée " "automatiquement quand la file est collectée par le ramasse-miettes." #: library/multiprocessing.rst:881 msgid "" "Join the background thread. This can only be used after :meth:`close` has " "been called. It blocks until the background thread exits, ensuring that all " "data in the buffer has been flushed to the pipe." 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." #: library/multiprocessing.rst:885 msgid "" "By default if a process is not the creator of the queue then on exit it will " "attempt to join the queue's background thread. The process can call :meth:" "`cancel_join_thread` to make :meth:`join_thread` do nothing." msgstr "" "Par défaut si un processus n'est pas le créateur de la file alors à la " "fermeture elle essaie d'attendre le fil d'exécution d'arrière-plan de la " "file. Le processus peut appeler :meth:`cancel_join_thread` pour que :meth:" "`join_thread` ne fasse rien." #: library/multiprocessing.rst:891 msgid "" "Prevent :meth:`join_thread` from blocking. In particular, this prevents the " "background thread from being joined automatically when the process exits -- " "see :meth:`join_thread`." 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`." #: library/multiprocessing.rst:895 msgid "" "A better name for this method might be ``allow_exit_without_flush()``. It " "is likely to cause enqueued data to be lost, and you almost certainly will " "not need to use it. It is really only there if you need the current process " "to exit immediately without waiting to flush enqueued data to the underlying " "pipe, and you don't care about lost data." msgstr "" "Un meilleur nom pour cette méthode pourrait être " "``allow_exit_without_flush()``. Cela peut provoquer des pertes de données " "placées dans la file, et il est très rare d'avoir besoin de l'utiliser. Elle " "n'est là que si vous souhaitez terminer immédiatement le processus sans " "transférer les données du tampon, et que vous êtes prêt à perdre des données." #: library/multiprocessing.rst:904 msgid "" "This class's functionality requires a functioning shared semaphore " "implementation on the host operating system. Without one, the functionality " "in this class will be disabled, and attempts to instantiate a :class:`Queue` " "will result in an :exc:`ImportError`. See :issue:`3770` for additional " "information. The same holds true for any of the specialized queue types " "listed below." msgstr "" "Le fonctionnement de cette classe requiert une implémentation de sémaphore " "partagé sur le système d'exploitation hôte. Sans cela, la fonctionnalité est " "désactivée et la tentative d'instancier une :class:`Queue` lève une :exc:" "`ImportError`. Voir :issue:`3770` pour plus d'informations. Cette remarque " "reste valable pour les autres types de files spécialisées définies par la " "suite." #: library/multiprocessing.rst:913 msgid "" "It is a simplified :class:`Queue` type, very close to a locked :class:`Pipe`." msgstr "" "Un type de :class:`Queue` simplifié, très proche d'un :class:`Pipe` avec " "verrou." #: library/multiprocessing.rst:917 msgid "Close the queue: release internal resources." msgstr "Ferme la file : libère les ressources internes." #: library/multiprocessing.rst:919 msgid "" "A queue must not be used anymore after it is closed. For example, :meth:" "`get`, :meth:`put` and :meth:`empty` methods must no longer be called." msgstr "" "Une file ne doit plus être utilisée après sa fermeture. Par exemple, les " "méthodes :meth:`get`, :meth:`put` et :meth:`empty` ne doivent plus être " "appelées." #: library/multiprocessing.rst:927 msgid "Return ``True`` if the queue is empty, ``False`` otherwise." msgstr "Renvoie ``True`` si la file est vide, ``False`` sinon." #: library/multiprocessing.rst:931 msgid "Remove and return an item from the queue." msgstr "Supprime et renvoie un élément de la file." #: library/multiprocessing.rst:935 msgid "Put *item* into the queue." msgstr "Place *item* dans la file." #: library/multiprocessing.rst:940 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 file qui " "ajoute des méthodes :meth:`task_done` et :meth:`join`." #: library/multiprocessing.rst:945 msgid "" "Indicate that a formerly enqueued task is complete. Used by queue " "consumers. For each :meth:`~Queue.get` used to fetch a task, a subsequent " "call to :meth:`task_done` tells the queue that the processing on the task is " "complete." msgstr "" "Indique qu'une tâche précédemment placée dans la file est achevée. Utilisée " "par les consommateurs de la file. Pour chaque :meth:`~Queue.get` utilisée " "pour récupérer une tâche, un appel ultérieur à :meth:`task_done` indique à " "la file que le traitement de la tâche est terminé." #: library/multiprocessing.rst:950 msgid "" "If a :meth:`~queue.Queue.join` is currently blocking, it will resume when " "all items have been processed (meaning that a :meth:`task_done` call was " "received for every item that had been :meth:`~Queue.put` into the queue)." msgstr "" "Si un :meth:`~queue.Queue.join` est actuellement bloquant, il se débloquera " "quand tous les éléments auront été traités (signifiant qu'un appel à :meth:" "`task_done` a été reçu pour chaque élément ayant été placé via :meth:`~Queue." "put` dans la file)." #: library/multiprocessing.rst:954 msgid "" "Raises a :exc:`ValueError` if called more times than there were items placed " "in the queue." msgstr "" "Lève une exception :exc:`ValueError` si appelée plus de fois qu'il y avait " "d'éléments dans la file." #: library/multiprocessing.rst:960 msgid "Block until all items in the queue have been gotten and processed." msgstr "" "Bloque jusqu'à ce que tous les éléments de la file aient été récupérés et " "traités." #: library/multiprocessing.rst:962 msgid "" "The count of unfinished tasks goes up whenever an item is added to the " "queue. The count goes down whenever a consumer calls :meth:`task_done` to " "indicate that the item was retrieved and all work on it is complete. When " "the count of unfinished tasks drops to zero, :meth:`~queue.Queue.join` " "unblocks." msgstr "" "Le compteur des tâches non accomplies augmente chaque fois qu'un élément est " "ajouté à la file. Le compteur redescend chaque fois qu'un consommateur " "appelle :meth:`task_done` pour indiquer qu'un élément a été récupéré et que " "tout le travail qui le concerne est complété. Quand le compteur des tâches " "non accomplies atteint zéro, :meth:`~queue.Queue.join` est débloquée." #: library/multiprocessing.rst:970 msgid "Miscellaneous" msgstr "Divers" #: library/multiprocessing.rst:974 msgid "Return list of all live children of the current process." msgstr "Renvoie la liste de tous les fils vivants du processus courant." #: library/multiprocessing.rst:976 msgid "" "Calling this has the side effect of \"joining\" any processes which have " "already finished." msgstr "" "Appeler cette méthode provoque l'effet de bord d'attendre tout processus qui " "n'a pas encore terminé." #: library/multiprocessing.rst:981 msgid "Return the number of CPUs in the system." msgstr "Renvoie le nombre de CPUs sur le système." #: library/multiprocessing.rst:983 msgid "" "This number is not equivalent to the number of CPUs the current process can " "use. The number of usable CPUs can be obtained with ``len(os." "sched_getaffinity(0))``" msgstr "" "Ce nombre n'est pas équivalent au nombre de CPUs que le processus courant " "peut utiliser. Le nombre de CPUs utilisables peut être obtenu avec ``len(os." "sched_getaffinity(0))``" #: library/multiprocessing.rst:987 msgid "" "When the number of CPUs cannot be determined a :exc:`NotImplementedError` is " "raised." msgstr "" "Une :exc:`NotImplementedError` est levée quand il est impossible de " "déterminer ce nombre." #: library/multiprocessing.rst:991 msgid ":func:`os.cpu_count`" msgstr ":func:`os.cpu_count`" #: library/multiprocessing.rst:995 msgid "" "Return the :class:`Process` object corresponding to the current process." msgstr "Renvoie l'objet :class:`Process` correspondant au processus courant." #: library/multiprocessing.rst:997 msgid "An analogue of :func:`threading.current_thread`." msgstr "Un analogue à :func:`threading.current_thread`." #: library/multiprocessing.rst:1001 msgid "" "Return the :class:`Process` object corresponding to the parent process of " "the :func:`current_process`. For the main process, ``parent_process`` will " "be ``None``." msgstr "" "Renvoie l'objet :class:`Process` correspondant au processus père de :func:" "`current_process`. Pour le processus maître, ``parent_process`` vaut " "``None``." #: library/multiprocessing.rst:1009 msgid "" "Add support for when a program which uses :mod:`multiprocessing` has been " "frozen to produce a Windows executable. (Has been tested with **py2exe**, " "**PyInstaller** and **cx_Freeze**.)" msgstr "" "Ajoute le support des programmes utilisant :mod:`multiprocessing` qui ont " "été figés pour produire un exécutable Windows (testé avec **py2exe**, " "**PyInstaller** et **cx_Freeze**)." #: library/multiprocessing.rst:1013 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 ::" #: library/multiprocessing.rst:1025 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 figé lève une :exc:`RuntimeError`." #: library/multiprocessing.rst:1028 msgid "" "Calling ``freeze_support()`` has no effect when invoked on any operating " "system other than Windows. In addition, if the module is being run normally " "by the Python interpreter on Windows (the program has not been frozen), then " "``freeze_support()`` has no effect." msgstr "" "Appeler ``freeze_support()`` n'a pas d'effet quand elle est invoquée sur un " "système d'exploitation autre que Windows. De plus, si le module est lancé " "normalement par l'interpréteur Python sous Windows (le programme n'a pas été " "figé), alors ``freeze_support()`` n'a pas d'effet." #: library/multiprocessing.rst:1035 msgid "" "Returns a list of the supported start methods, the first of which is the " "default. The possible start methods are ``'fork'``, ``'spawn'`` and " "``'forkserver'``. On Windows only ``'spawn'`` is available. On Unix " "``'fork'`` and ``'spawn'`` are always supported, with ``'fork'`` being the " "default." 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." #: library/multiprocessing.rst:1045 msgid "" "Return a context object which has the same attributes as the :mod:" "`multiprocessing` module." msgstr "" "Renvoie un contexte ayant les mêmes attributs que le module :mod:" "`multiprocessing`." #: library/multiprocessing.rst:1048 msgid "" "If *method* is ``None`` then the default context is returned. Otherwise " "*method* should be ``'fork'``, ``'spawn'``, ``'forkserver'``. :exc:" "`ValueError` is raised if the specified start method is not available." 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." #: library/multiprocessing.rst:1057 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." #: library/multiprocessing.rst:1059 msgid "" "If the start method has not been fixed and *allow_none* is false, then the " "start method is fixed to the default and the name is returned. If the start " "method has not been fixed and *allow_none* is true then ``None`` is returned." 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é." #: library/multiprocessing.rst:1064 msgid "" "The return value can be ``'fork'``, ``'spawn'``, ``'forkserver'`` or " "``None``. ``'fork'`` is the default on Unix, while ``'spawn'`` is the " "default on Windows and macOS." 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 et macsOS." #: library/multiprocessing.rst:1078 #, fuzzy msgid "" "Set the path of the Python interpreter to use when starting a child process. " "(By default :data:`sys.executable` is used). Embedders will probably need " "to do some thing like ::" msgstr "" "Définit le chemin de l'interpréteur Python à utiliser pour démarrer un " "processus fils. (Par défaut :data:`sys.executable` est utilisé). Les " "intégrateurs devront probablement faire quelque chose comme ::" #: library/multiprocessing.rst:1084 msgid "before they can create child processes." msgstr "avant de pouvoir créer des processus fils." #: library/multiprocessing.rst:1086 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." #: library/multiprocessing.rst:1089 msgid "Accepts a :term:`path-like object`." msgstr "" #: library/multiprocessing.rst:1094 msgid "" "Set the method which should be used to start child processes. The *method* " "argument can be ``'fork'``, ``'spawn'`` or ``'forkserver'``. Raises :exc:" "`RuntimeError` if the start method has already been set and *force* is not " "``True``. If *method* is ``None`` and *force* is ``True`` then the start " "method is set to ``None``. If *method* is ``None`` and *force* is ``False`` " "then the context is set to the default context." msgstr "" #: library/multiprocessing.rst:1101 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." #: library/multiprocessing.rst:1109 msgid "" ":mod:`multiprocessing` contains no analogues of :func:`threading." "active_count`, :func:`threading.enumerate`, :func:`threading.settrace`, :" "func:`threading.setprofile`, :class:`threading.Timer`, or :class:`threading." "local`." 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`." #: library/multiprocessing.rst:1116 msgid "Connection Objects" msgstr "Objets de connexions" #: library/multiprocessing.rst:1120 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." #: library/multiprocessing.rst:1123 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`." #: library/multiprocessing.rst:1131 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 extrémité de la connexion, qui devra être lu " "avec :meth:`recv`." #: library/multiprocessing.rst:1134 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`." #: library/multiprocessing.rst:1139 msgid "" "Return an object sent from the other end of the connection using :meth:" "`send`. Blocks until there is something to receive. Raises :exc:`EOFError` " "if there is nothing left to receive and the other end was closed." msgstr "" "Renvoie un objet envoyé depuis l'autre extrémité de la connexion en " "utilisant :meth:`send`. Bloque jusqu'à ce que quelque chose soit reçu. Lève " "une :exc:`EOFError` s'il n'y a plus rien à recevoir et que l'autre extrémité " "a été fermée." #: library/multiprocessing.rst:1146 msgid "Return the file descriptor or handle used by the connection." msgstr "" "Renvoie le descripteur de fichier ou identifiant utilisé par la connexion." #: library/multiprocessing.rst:1150 msgid "Close the connection." msgstr "Ferme la connexion." #: library/multiprocessing.rst:1152 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." #: library/multiprocessing.rst:1156 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." #: library/multiprocessing.rst:1158 msgid "" "If *timeout* is not specified then it will return immediately. If *timeout* " "is a number then this specifies the maximum time in seconds to block. If " "*timeout* is ``None`` then an infinite timeout is used." 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é." #: library/multiprocessing.rst:1162 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`." #: library/multiprocessing.rst:1167 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." #: library/multiprocessing.rst:1169 msgid "" "If *offset* is given then data is read from that position in *buffer*. If " "*size* is given then that many bytes will be read from buffer. Very large " "buffers (approximately 32 MiB+, though it depends on the OS) may raise a :" "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`." #: library/multiprocessing.rst:1176 msgid "" "Return a complete message of byte data sent from the other end of the " "connection as a string. Blocks until there is something to receive. Raises :" "exc:`EOFError` if there is nothing left to receive and the other end has " "closed." msgstr "" "Renvoie un message complet de données binaires envoyées depuis l'autre " "extrémité de la connexion comme une chaîne de caractères. Bloque jusqu'à ce " "qu'il y ait quelque chose à recevoir. Lève une :exc:`EOFError` s'il ne reste " "rien à recevoir et que l'autre côté de la connexion a été fermé." #: library/multiprocessing.rst:1181 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." #: library/multiprocessing.rst:1185 msgid "" "This function used to raise :exc:`IOError`, which is now an alias of :exc:" "`OSError`." msgstr "" "Cette fonction levait auparavant une :exc:`IOError`, qui est maintenant un " "alias pour :exc:`OSError`." #: library/multiprocessing.rst:1192 msgid "" "Read into *buffer* a complete message of byte data sent from the other end " "of the connection and return the number of bytes in the message. Blocks " "until there is something to receive. Raises :exc:`EOFError` if there is " "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 extrémité de la connexion et renvoie le nombre d'octets du " "message. Bloque jusqu'à ce qu'il y ait quelque chose à recevoir. Lève une :" "exc:`EOFError` s'il ne reste rien à recevoir et que l'autre côté de la " "connexion a été fermé." #: library/multiprocessing.rst:1198 msgid "" "*buffer* must be a writable :term:`bytes-like object`. If *offset* is given " "then the message will be written into the buffer from that position. Offset " "must be a non-negative integer less than the length of *buffer* (in bytes)." 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)." #: library/multiprocessing.rst:1203 msgid "" "If the buffer is too short then a :exc:`BufferTooShort` exception is raised " "and the complete message is available as ``e.args[0]`` where ``e`` is the " "exception instance." 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." #: library/multiprocessing.rst:1207 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`." #: library/multiprocessing.rst:1211 msgid "" "Connection objects now support the context management protocol -- see :ref:" "`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the " "connection object, and :meth:`~contextmanager.__exit__` calls :meth:`close`." 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`." #: library/multiprocessing.rst:1216 msgid "For example:" msgstr "Par exemple :" #: library/multiprocessing.rst:1241 msgid "" "The :meth:`Connection.recv` method automatically unpickles the data it " "receives, which can be a security risk unless you can trust the process " "which sent the message." 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." #: library/multiprocessing.rst:1245 msgid "" "Therefore, unless the connection object was produced using :func:`Pipe` you " "should only use the :meth:`~Connection.recv` and :meth:`~Connection.send` " "methods after performing some sort of authentication. See :ref:" "`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`." #: library/multiprocessing.rst:1252 msgid "" "If a process is killed while it is trying to read or write to a pipe then " "the data in the pipe is likely to become corrupted, because it may become " "impossible to be sure where the message boundaries lie." 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." #: library/multiprocessing.rst:1258 msgid "Synchronization primitives" msgstr "Primitives de synchronisation" #: library/multiprocessing.rst:1262 msgid "" "Generally synchronization primitives are not as necessary in a multiprocess " "program as they are in a multithreaded program. See the documentation for :" "mod:`threading` module." 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`." #: library/multiprocessing.rst:1266 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`." #: library/multiprocessing.rst:1271 msgid "A barrier object: a clone of :class:`threading.Barrier`." msgstr "Un objet barrière : un clone de :class:`threading.Barrier`." #: library/multiprocessing.rst:1277 msgid "" "A bounded semaphore object: a close analog of :class:`threading." "BoundedSemaphore`." msgstr "" "Un objet sémaphore lié : un analogue proche de :class:`threading." "BoundedSemaphore`." #: library/multiprocessing.rst:1280 library/multiprocessing.rst:1418 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`." #: library/multiprocessing.rst:1284 msgid "" "On macOS, this is indistinguishable from :class:`Semaphore` because " "``sem_getvalue()`` is not implemented on that platform." msgstr "" "Sur macOS, elle n'est pas distinguable de la classe :class:`Semaphore` parce " "que ``sem_getvalue()`` n'est pas implémentée sur cette plateforme." #: library/multiprocessing.rst:1289 msgid "A condition variable: an alias for :class:`threading.Condition`." msgstr "" "Une variable conditionnelle : un alias pour :class:`threading.Condition`." #: library/multiprocessing.rst:1291 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`." #: library/multiprocessing.rst:1294 library/multiprocessing.rst:1843 msgid "The :meth:`~threading.Condition.wait_for` method was added." msgstr "La méthode :meth:`~threading.Condition.wait_for` a été ajoutée." #: library/multiprocessing.rst:1299 msgid "A clone of :class:`threading.Event`." msgstr "Un clone de :class:`threading.Event`." #: library/multiprocessing.rst:1304 msgid "" "A non-recursive lock object: a close analog of :class:`threading.Lock`. Once " "a process or thread has acquired a lock, subsequent attempts to acquire it " "from any process or thread will block until it is released; any process or " "thread may release it. The concepts and behaviors of :class:`threading." "Lock` as it applies to threads are replicated here in :class:" "`multiprocessing.Lock` as it applies to either processes or threads, except " "as noted." msgstr "" "Un verrou non récursif : un analogue proche de :class:`threading.Lock`. Une " "fois que le processus ou le fil d'exécution a acquis un verrou, les " "tentatives suivantes d'acquisition depuis n'importe quel processus ou fil " "d'exécution bloqueront jusqu'à ce qu'il soit libéré ; n'importe quel " "processus ou fil peut le libérer. Les concepts et comportements de :class:" "`threading.Lock` qui s'appliquent aux fils d'exécution sont répliqués ici " "dans :class:`multiprocessing.Lock` et s'appliquent aux processus et aux fils " "d'exécution, à l'exception de ce qui est indiqué." #: library/multiprocessing.rst:1312 msgid "" "Note that :class:`Lock` is actually a factory function which returns an " "instance of ``multiprocessing.synchronize.Lock`` initialized with a default " "context." msgstr "" "Notez que :class:`Lock` est en fait une fonction *factory* qui renvoie une " "instance de ``multiprocessing.synchronize.Lock`` initialisée avec un " "contexte par défaut." #: library/multiprocessing.rst:1316 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`." #: library/multiprocessing.rst:1321 library/multiprocessing.rst:1372 msgid "Acquire a lock, blocking or non-blocking." msgstr "Acquiert un verrou, bloquant ou non bloquant." #: library/multiprocessing.rst:1323 msgid "" "With the *block* argument set to ``True`` (the default), the method call " "will block until the lock is in an unlocked state, then set it to locked and " "return ``True``. Note that the name of this first argument differs from " "that in :meth:`threading.Lock.acquire`." 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`." #: library/multiprocessing.rst:1328 msgid "" "With the *block* argument set to ``False``, the method call does not block. " "If the lock is currently in a locked state, return ``False``; otherwise set " "the lock to a locked state and return ``True``." 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``." #: library/multiprocessing.rst:1332 msgid "" "When invoked with a positive, floating-point value for *timeout*, block for " "at most the number of seconds specified by *timeout* as long as the lock can " "not be acquired. Invocations with a negative value for *timeout* are " "equivalent to a *timeout* of zero. Invocations with a *timeout* value of " "``None`` (the default) set the timeout period to infinite. Note that the " "treatment of negative or ``None`` values for *timeout* differs from the " "implemented behavior in :meth:`threading.Lock.acquire`. The *timeout* " "argument has no practical implications if the *block* argument is set to " "``False`` and is thus ignored. Returns ``True`` if the lock has been " "acquired or ``False`` if the timeout period has elapsed." msgstr "" "Quand invoqué avec un nombre flottant positif comme *timeout*, bloque au " "maximum pendant ce nombre spécifié de secondes, tant que le verrou ne peut " "être acquis. Les invocations avec une valeur de *timeout* négatives sont " "équivalents à zéro. Les invocations avec un *timeout* à ``None`` (par " "défaut) correspondent à un délai d'attente infini. Notez que le traitement " "des valeurs de *timeout* négatives et ``None`` diffère du comportement " "implémenté dans :meth:`threading.Lock.acquire`. L'argument *timeout* n'a pas " "d'implication pratique si l'argument *block* est mis ) ``False`` et est " "alors ignoré. Renvoie ``True`` si le verrou a été acquis et ``False`` si le " "temps de *timeout* a expiré." #: library/multiprocessing.rst:1347 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." #: library/multiprocessing.rst:1350 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." #: library/multiprocessing.rst:1356 msgid "" "A recursive lock object: a close analog of :class:`threading.RLock`. A " "recursive lock must be released by the process or thread that acquired it. " "Once a process or thread has acquired a recursive lock, the same process or " "thread may acquire it again without blocking; that process or thread must " "release it once for each time it has been acquired." 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." #: library/multiprocessing.rst:1362 msgid "" "Note that :class:`RLock` is actually a factory function which returns an " "instance of ``multiprocessing.synchronize.RLock`` initialized with a default " "context." msgstr "" "Notez que :class:`RLock` est en fait une fonction *factory* qui renvoie une " "instance de ``multiprocessing.synchronize.RLock`` initialisée avec un " "contexte par défaut." #: library/multiprocessing.rst:1366 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`." #: library/multiprocessing.rst:1374 msgid "" "When invoked with the *block* argument set to ``True``, block until the lock " "is in an unlocked state (not owned by any process or thread) unless the lock " "is already owned by the current process or thread. The current process or " "thread then takes ownership of the lock (if it does not already have " "ownership) and the recursion level inside the lock increments by one, " "resulting in a return value of ``True``. Note that there are several " "differences in this first argument's behavior compared to the implementation " "of :meth:`threading.RLock.acquire`, starting with the name of the argument " "itself." msgstr "" "Quand invoqué avec l'argument *block* à ``True``, bloque jusqu'à ce que le " "verrou soit déverrouillé (n'appartenant à aucun processus ou fil " "d'exécution) sauf s'il appartient déjà au processus ou fil d'exécution " "courant. Le processus ou fil d'exécution courant prend la possession du " "verrou (s'il ne l'a pas déjà) et incrémente d'un le niveau de récursion du " "verrou, renvoyant ainsi ``True``. Notez qu'il y a plusieurs différences dans " "le comportement de ce premier argument comparé à l'implémentation de :meth:" "`threading.RLock.acquire`, à commencer par le nom de l'argument lui-même." #: library/multiprocessing.rst:1384 msgid "" "When invoked with the *block* argument set to ``False``, do not block. If " "the lock has already been acquired (and thus is owned) by another process or " "thread, the current process or thread does not take ownership and the " "recursion level within the lock is not changed, resulting in a return value " "of ``False``. If the lock is in an unlocked state, the current process or " "thread takes ownership and the recursion level is incremented, resulting in " "a return value of ``True``." msgstr "" "Quand invoqué avec l'argument *block* à ``False``, ne bloque pas. Si le " "verrou est déjà acquis (et possédé) par un autre processus ou fil " "d'exécution, le processus/fil courant n'en prend pas la possession et le " "niveau de récursion n'est pas incrémenté, résultant en une valeur de retour " "à ``False``. Si le verrou est déverrouillé, le processus/fil courant en " "prend possession et incrémente son niveau de récursion, renvoyant ``True``." #: library/multiprocessing.rst:1392 msgid "" "Use and behaviors of the *timeout* argument are the same as in :meth:`Lock." "acquire`. Note that some of these behaviors of *timeout* differ from the " "implemented behaviors in :meth:`threading.RLock.acquire`." 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`." #: library/multiprocessing.rst:1399 msgid "" "Release a lock, decrementing the recursion level. If after the decrement " "the recursion level is zero, reset the lock to unlocked (not owned by any " "process or thread) and if any other processes or threads are blocked waiting " "for the lock to become unlocked, allow exactly one of them to proceed. If " "after the decrement the recursion level is still nonzero, the lock remains " "locked and owned by the calling process or thread." msgstr "" "Libère un verrou, décrémentant son niveau de récursion. Si après la " "décrémentation le niveau de récursion est zéro, réinitialise le verrou à un " "état déverrouillé (n'appartenant à aucun processus ou fil d'exécution) et si " "des processus/fils attendent que le verrou se déverrouillé, autorise un seul " "d'entre-eux à continuer. Si après cette décrémentation le niveau de " "récursion est toujours strictement positif, le verrou reste verrouillé et " "propriété du processus/fil appelant." #: library/multiprocessing.rst:1407 msgid "" "Only call this method when the calling process or thread owns the lock. An :" "exc:`AssertionError` is raised if this method is called by a process or " "thread other than the owner or if the lock is in an unlocked (unowned) " "state. Note that the type of exception raised in this situation differs " "from the implemented behavior in :meth:`threading.RLock.release`." 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`." #: library/multiprocessing.rst:1416 msgid "A semaphore object: a close analog of :class:`threading.Semaphore`." msgstr "Un objet sémaphore, proche analogue de :class:`threading.Semaphore`." #: library/multiprocessing.rst:1423 msgid "" "On macOS, ``sem_timedwait`` is unsupported, so calling ``acquire()`` with a " "timeout will emulate that function's behavior using a sleeping loop." msgstr "" "Sous macOS, ``sem_timedwait`` n'est pas pris en charge, donc appeler " "``acquire()`` avec un temps d'exécution limité émule le comportement de " "cette fonction en utilisant une boucle d'attente." #: library/multiprocessing.rst:1428 msgid "" "If the SIGINT signal generated by :kbd:`Ctrl-C` arrives while the main " "thread is blocked by a call to :meth:`BoundedSemaphore.acquire`, :meth:`Lock." "acquire`, :meth:`RLock.acquire`, :meth:`Semaphore.acquire`, :meth:`Condition." "acquire` or :meth:`Condition.wait` then the call will be immediately " "interrupted and :exc:`KeyboardInterrupt` will be raised." 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." #: library/multiprocessing.rst:1434 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." #: library/multiprocessing.rst:1439 msgid "" "Some of this package's functionality requires a functioning shared semaphore " "implementation on the host operating system. Without one, the :mod:" "`multiprocessing.synchronize` module will be disabled, and attempts to " "import it will result in an :exc:`ImportError`. See :issue:`3770` for " "additional information." 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." #: library/multiprocessing.rst:1447 msgid "Shared :mod:`ctypes` Objects" msgstr "Objets :mod:`ctypes` partagés" #: library/multiprocessing.rst:1449 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 fils." #: library/multiprocessing.rst:1454 msgid "" "Return a :mod:`ctypes` object allocated from shared memory. By default the " "return value is actually a synchronized wrapper for the object. The object " "itself can be accessed via the *value* attribute of a :class:`Value`." msgstr "" "Renvoie un objet :mod:`ctypes` alloué depuis la mémoire partagée. Par défaut " "la valeur de retour est en fait un *wrapper* synchronisé autour de l'objet. " "L'objet en lui-même est accessible par l'attribut *value* de l'une :class:" "`Value`." #: library/multiprocessing.rst:1458 library/multiprocessing.rst:1545 msgid "" "*typecode_or_type* determines the type of the returned object: it is either " "a ctypes type or a one character typecode of the kind used by the :mod:" "`array` module. *\\*args* is passed on to the constructor for the type." 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." #: library/multiprocessing.rst:1462 msgid "" "If *lock* is ``True`` (the default) then a new recursive lock object is " "created to synchronize access to the value. If *lock* is a :class:`Lock` " "or :class:`RLock` object then that will be used to synchronize access to the " "value. If *lock* is ``False`` then access to the returned object will not " "be automatically protected by a lock, so it will not necessarily be " "\"process-safe\"." 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* »." #: library/multiprocessing.rst:1469 msgid "" "Operations like ``+=`` which involve a read and write are not atomic. So " "if, for instance, you want to atomically increment a shared value it is " "insufficient to just do ::" msgstr "" "Les opérations telles que ``+=`` qui impliquent une lecture et une écriture " "ne sont pas atomiques. Ainsi si vous souhaitez par exemple réaliser une " "incrémentation atomique sur une valeur partagée, vous ne pouvez pas " "simplement faire ::" #: library/multiprocessing.rst:1475 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 ::" #: library/multiprocessing.rst:1481 library/multiprocessing.rst:1571 #: library/multiprocessing.rst:1586 msgid "Note that *lock* is a keyword-only argument." msgstr "Notez que *lock* est un argument *keyword-only*." #: library/multiprocessing.rst:1485 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." #: library/multiprocessing.rst:1488 msgid "" "*typecode_or_type* determines the type of the elements of the returned " "array: it is either a ctypes type or a one character typecode of the kind " "used by the :mod:`array` module. If *size_or_initializer* is an integer, " "then it determines the length of the array, and the array will be initially " "zeroed. Otherwise, *size_or_initializer* is a sequence which is used to " "initialize the array and whose length determines the length of the array." msgstr "" "*typecode_or_type* détermine le type des éléments du tableau renvoyé : il " "s'agit soit d'un type *ctype* soit d'un caractère *typecode* tel qu'utilisé " "par le module :mod:`array`. Si *size_or_initialize* est un entier, alors il " "détermine la taille du tableau, et le tableau sera initialisé avec des " "zéros. Autrement, *size*or_initializer* est une séquence qui sera utilisée " "pour initialiser le tableau et dont la taille détermine celle du tableau." #: library/multiprocessing.rst:1495 msgid "" "If *lock* is ``True`` (the default) then a new lock object is created to " "synchronize access to the value. If *lock* is a :class:`Lock` or :class:" "`RLock` object then that will be used to synchronize access to the value. " "If *lock* is ``False`` then access to the returned object will not be " "automatically protected by a lock, so it will not necessarily be \"process-" "safe\"." 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* »." #: library/multiprocessing.rst:1502 msgid "Note that *lock* is a keyword only argument." msgstr "Notez que *lock* est un argument *keyword-only*." #: library/multiprocessing.rst:1504 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." #: library/multiprocessing.rst:1509 msgid "The :mod:`multiprocessing.sharedctypes` module" msgstr "Le module :mod:`multiprocessing.sharedctypes`" #: library/multiprocessing.rst:1514 msgid "" "The :mod:`multiprocessing.sharedctypes` module provides functions for " "allocating :mod:`ctypes` objects from shared memory which can be inherited " "by child processes." msgstr "" "Le module :mod:`multiprocessing.sharedctypes` fournit des fonctions pour " "allouer des objets :mod:`ctypes` depuis la mémoire partagée, qui peuvent " "être hérités par les processus fils." #: library/multiprocessing.rst:1520 msgid "" "Although it is possible to store a pointer in shared memory remember that " "this will refer to a location in the address space of a specific process. " "However, the pointer is quite likely to be invalid in the context of a " "second process and trying to dereference the pointer from the second process " "may cause a crash." msgstr "" "Bien qu'il soit possible de stocker un pointeur en mémoire partagée, " "rappelez-vous qu'un pointer référence un emplacement dans l'espace " "d'adressage d'un processus particulier. Ainsi, ce pointeur a de fortes " "chances d'être invalide dans le contexte d'un autre processus et " "déréférencer le pointeur depuis ce second processus peut causer un plantage." #: library/multiprocessing.rst:1528 msgid "Return a ctypes array allocated from shared memory." msgstr "Renvoie un tableau *ctypes* alloué depuis la mémoire partagée." #: library/multiprocessing.rst:1530 msgid "" "*typecode_or_type* determines the type of the elements of the returned " "array: it is either a ctypes type or a one character typecode of the kind " "used by the :mod:`array` module. If *size_or_initializer* is an integer " "then it determines the length of the array, and the array will be initially " "zeroed. Otherwise *size_or_initializer* is a sequence which is used to " "initialize the array and whose length determines the length of the array." msgstr "" "*typecode_or_type* détermine le type des éléments du tableau renvoyé : il " "s'agit soit d'un type *ctype* soit d'un caractère codant le type des " "éléments du tableau (*typecode*) tel qu'utilisé par le module :mod:`array`. " "Si *size_or_initialize* est un entier, alors il détermine la taille du " "tableau, et le tableau sera initialisé avec des zéros. Autrement, " "*size_or_initializer* est une séquence qui sera utilisée pour initialiser le " "tableau et dont la taille détermine celle du tableau." #: library/multiprocessing.rst:1537 msgid "" "Note that setting and getting an element is potentially non-atomic -- use :" "func:`Array` instead to make sure that access is automatically synchronized " "using a lock." 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." #: library/multiprocessing.rst:1543 msgid "Return a ctypes object allocated from shared memory." msgstr "Renvoie un objet *ctypes* alloué depuis la mémoire partagée." #: library/multiprocessing.rst:1549 msgid "" "Note that setting and getting the value is potentially non-atomic -- use :" "func:`Value` instead to make sure that access is automatically synchronized " "using a lock." 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." #: library/multiprocessing.rst:1553 msgid "" "Note that an array of :data:`ctypes.c_char` has ``value`` and ``raw`` " "attributes which allow one to use it to store and retrieve strings -- see " "documentation for :mod:`ctypes`." 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`." #: library/multiprocessing.rst:1559 msgid "" "The same as :func:`RawArray` except that depending on the value of *lock* a " "process-safe synchronization wrapper may be returned instead of a raw ctypes " "array." 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." #: library/multiprocessing.rst:1563 library/multiprocessing.rst:1579 msgid "" "If *lock* is ``True`` (the default) then a new lock object is created to " "synchronize access to the value. If *lock* is a :class:`~multiprocessing." "Lock` or :class:`~multiprocessing.RLock` object then that will be used to " "synchronize access to the value. If *lock* is ``False`` then access to the " "returned object will not be automatically protected by a lock, so it will " "not necessarily be \"process-safe\"." 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* »." #: library/multiprocessing.rst:1575 msgid "" "The same as :func:`RawValue` except that depending on the value of *lock* a " "process-safe synchronization wrapper may be returned instead of a raw ctypes " "object." 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." #: library/multiprocessing.rst:1590 msgid "" "Return a ctypes object allocated from shared memory which is a copy of the " "ctypes object *obj*." msgstr "" "Renvoie un objet *ctypes* alloué depuis la mémoire partagée, qui est une " "copie de l'objet *ctypes* *obj*." #: library/multiprocessing.rst:1595 msgid "" "Return a process-safe wrapper object for a ctypes object which uses *lock* " "to synchronize access. If *lock* is ``None`` (the default) then a :class:" "`multiprocessing.RLock` object is created automatically." 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." #: library/multiprocessing.rst:1599 msgid "" "A synchronized wrapper will have two methods in addition to those of the " "object it wraps: :meth:`get_obj` returns the wrapped object and :meth:" "`get_lock` returns the lock object used for synchronization." 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." #: library/multiprocessing.rst:1603 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." #: library/multiprocessing.rst:1606 msgid "Synchronized objects support the :term:`context manager` protocol." msgstr "" "Les objets synchronisés supportent le protocole :term:`context manager`." #: library/multiprocessing.rst:1610 msgid "" "The table below compares the syntax for creating shared ctypes objects from " "shared memory with the normal ctypes syntax. (In the table ``MyStruct`` is " "some subclass of :class:`ctypes.Structure`.)" 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`.)" #: library/multiprocessing.rst:1615 msgid "ctypes" msgstr "ctypes" #: library/multiprocessing.rst:1615 msgid "sharedctypes using type" msgstr "*sharedctypes* utilisant un type" #: library/multiprocessing.rst:1615 msgid "sharedctypes using typecode" msgstr "*sharedctypes* utilisant un *typecode*" #: library/multiprocessing.rst:1617 msgid "c_double(2.4)" msgstr "c_double(2.4)" #: library/multiprocessing.rst:1617 msgid "RawValue(c_double, 2.4)" msgstr "RawValue(c_double, 2.4)" #: library/multiprocessing.rst:1617 msgid "RawValue('d', 2.4)" msgstr "RawValue('d', 2.4)" #: library/multiprocessing.rst:1618 msgid "MyStruct(4, 6)" msgstr "MyStruct(4, 6)" #: library/multiprocessing.rst:1618 msgid "RawValue(MyStruct, 4, 6)" msgstr "RawValue(MyStruct, 4, 6)" #: library/multiprocessing.rst:1619 msgid "(c_short * 7)()" msgstr "(c_short * 7)()" #: library/multiprocessing.rst:1619 msgid "RawArray(c_short, 7)" msgstr "RawArray(c_short, 7)" #: library/multiprocessing.rst:1619 msgid "RawArray('h', 7)" msgstr "RawArray('h', 7)" #: library/multiprocessing.rst:1620 msgid "(c_int * 3)(9, 2, 8)" msgstr "(c_int * 3)(9, 2, 8)" #: library/multiprocessing.rst:1620 msgid "RawArray(c_int, (9, 2, 8))" msgstr "RawArray(c_int, (9, 2, 8))" #: library/multiprocessing.rst:1620 msgid "RawArray('i', (9, 2, 8))" msgstr "RawArray('i', (9, 2, 8))" #: library/multiprocessing.rst:1624 msgid "" "Below is an example where a number of ctypes objects are modified by a child " "process::" msgstr "" "Ci-dessous un exemple où des objets *ctypes* sont modifiés par un processus " "fils ::" #: library/multiprocessing.rst:1662 msgid "The results printed are ::" msgstr "Les résultats affichés sont ::" #: library/multiprocessing.rst:1675 msgid "Managers" msgstr "Gestionnaires" #: library/multiprocessing.rst:1677 msgid "" "Managers provide a way to create data which can be shared between different " "processes, including sharing over a network between processes running on " "different machines. A manager object controls a server process which manages " "*shared objects*. Other processes can access the shared objects by using " "proxies." 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." #: library/multiprocessing.rst:1686 msgid "" "Returns a started :class:`~multiprocessing.managers.SyncManager` object " "which can be used for sharing objects between processes. The returned " "manager object corresponds to a spawned child process and has methods which " "will create shared objects and return corresponding proxies." 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 fils instancié et possède des " "méthodes pour créer des objets partagés et renvoyer les mandataires " "correspondants." #: library/multiprocessing.rst:1694 msgid "" "Manager processes will be shutdown as soon as they are garbage collected or " "their parent process exits. The manager classes are defined in the :mod:" "`multiprocessing.managers` module:" 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` :" #: library/multiprocessing.rst:1700 msgid "Create a BaseManager object." msgstr "Crée un objet *BaseManager*." #: library/multiprocessing.rst:1702 msgid "" "Once created one should call :meth:`start` or ``get_server()." "serve_forever()`` to ensure that the manager object refers to a started " "manager process." 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é." #: library/multiprocessing.rst:1705 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." #: library/multiprocessing.rst:1708 msgid "" "*authkey* is the authentication key which will be used to check the validity " "of incoming connections to the server process. If *authkey* is ``None`` " "then ``current_process().authkey`` is used. Otherwise *authkey* is used and " "it must be a byte string." 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." #: library/multiprocessing.rst:1713 msgid "" "*serializer* must be ``'pickle'`` (use :mod:`pickle` serialization) or " "``'xmlrpclib'`` (use :mod:`xmlrpc.client` serialization)." msgstr "" #: library/multiprocessing.rst:1716 msgid "" "*ctx* is a context object, or ``None`` (use the current context). See the :" "func:`get_context` function." msgstr "" #: library/multiprocessing.rst:1719 msgid "" "*shutdown_timeout* is a timeout in seconds used to wait until the process " "used by the manager completes in the :meth:`shutdown` method. If the " "shutdown times out, the process is terminated. If terminating the process " "also times out, the process is killed." msgstr "" #: library/multiprocessing.rst:1724 #, fuzzy msgid "Added the *shutdown_timeout* parameter." msgstr "Ajout de l'argument *daemon*." #: library/multiprocessing.rst:1729 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." #: library/multiprocessing.rst:1734 msgid "" "Returns a :class:`Server` object which represents the actual server under " "the control of the Manager. The :class:`Server` object supports the :meth:" "`serve_forever` method::" 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` ::" #: library/multiprocessing.rst:1743 msgid ":class:`Server` additionally has an :attr:`address` attribute." msgstr ":class:`Server` possède en plus un attribut :attr:`address`." #: library/multiprocessing.rst:1747 msgid "Connect a local manager object to a remote manager process::" msgstr "" "Connecte un objet gestionnaire local au processus gestionnaire distant ::" #: library/multiprocessing.rst:1755 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." #: library/multiprocessing.rst:1758 msgid "This can be called multiple times." msgstr "Cette méthode peut être appelée plusieurs fois." #: library/multiprocessing.rst:1762 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." #: library/multiprocessing.rst:1765 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." #: library/multiprocessing.rst:1768 msgid "" "*callable* is a callable used for creating objects for this type " "identifier. If a manager instance will be connected to the server using " "the :meth:`connect` method, or if the *create_method* argument is ``False`` " "then this can be left as ``None``." 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``." #: library/multiprocessing.rst:1774 msgid "" "*proxytype* is a subclass of :class:`BaseProxy` which is used to create " "proxies for shared objects with this *typeid*. If ``None`` then a proxy " "class is created automatically." 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." #: library/multiprocessing.rst:1778 msgid "" "*exposed* is used to specify a sequence of method names which proxies for " "this typeid should be allowed to access using :meth:`BaseProxy." "_callmethod`. (If *exposed* is ``None`` then :attr:`proxytype._exposed_` is " "used instead if it exists.) In the case where no exposed list is specified, " "all \"public methods\" of the shared object will be accessible. (Here a " "\"public method\" means any attribute which has a :meth:`~object.__call__` " "method and whose name does not begin with ``'_'``.)" msgstr "" "*exposed* est utilisé pour préciser une séquence de noms de méthodes dont " "les mandataires pour ce *typeid* doivent être autorisés à accéder via :meth:" "`BaseProxy._callmethod`. (Si *exposed* est ``None`` alors :attr:`proxytype." "_exposed_` est utilisé à la place s'il existe.) Dans le cas où aucune liste " "*exposed* n'est précisée, toutes les « méthodes publiques » de l'objet " "partagé seront accessibles. (Ici une « méthode publique » signifie n'importe " "quel attribut qui possède une méthode :meth:`~object.__call__` et dont le " "nom ne commence pas par un ``'_'``.)" #: library/multiprocessing.rst:1787 msgid "" "*method_to_typeid* is a mapping used to specify the return type of those " "exposed methods which should return a proxy. It maps method names to typeid " "strings. (If *method_to_typeid* is ``None`` then :attr:`proxytype." "_method_to_typeid_` is used instead if it exists.) If a method's name is " "not a key of this mapping or if the mapping is ``None`` then the object " "returned by the method will be copied by value." msgstr "" "*method_to_typeid* est un tableau associatif utilisé pour préciser le type " "de retour de ces méthodes exposées qui doivent renvoyer un mandataire. Il " "associé un nom de méthode à une chaîne de caractères *typeid*. (Si " "*method_to_typeid* est ``None``, :attr:`proxytype._method_to_typeid_` est " "utilisé à la place s'il existe). Si le nom d'une méthode n'est pas une clé " "de ce tableau associatif ou si la valeur associée est ``None``, l'objet " "renvoyé par la méthode sera une copie de la valeur." #: library/multiprocessing.rst:1794 msgid "" "*create_method* determines whether a method should be created with name " "*typeid* which can be used to tell the server process to create a new shared " "object and return a proxy for it. By default it is ``True``." 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``." #: library/multiprocessing.rst:1798 msgid ":class:`BaseManager` instances also have one read-only property:" msgstr "" "Les instances de :class:`BaseManager` ont aussi une propriété en lecture " "seule :" #: library/multiprocessing.rst:1802 msgid "The address used by the manager." msgstr "L'adresse utilisée par le gestionnaire." #: library/multiprocessing.rst:1804 msgid "" "Manager objects support the context management protocol -- see :ref:" "`typecontextmanager`. :meth:`~contextmanager.__enter__` starts the server " "process (if it has not already started) and then returns the manager " "object. :meth:`~contextmanager.__exit__` calls :meth:`shutdown`." 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`." #: library/multiprocessing.rst:1810 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é." #: library/multiprocessing.rst:1815 msgid "" "A subclass of :class:`BaseManager` which can be used for the synchronization " "of processes. Objects of this type are returned by :func:`multiprocessing." "Manager`." 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`." #: library/multiprocessing.rst:1819 msgid "" "Its methods create and return :ref:`multiprocessing-proxy_objects` for a " "number of commonly used data types to be synchronized across processes. This " "notably includes shared lists and dictionaries." 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." #: library/multiprocessing.rst:1825 msgid "" "Create a shared :class:`threading.Barrier` object and return a proxy for it." msgstr "" "Crée un objet :class:`threading.Barrier` partagé et renvoie un mandataire " "pour cet objet." #: library/multiprocessing.rst:1832 msgid "" "Create a shared :class:`threading.BoundedSemaphore` object and return a " "proxy for it." msgstr "" "Crée un objet :class:`threading.BoundedSemaphore` partagé et renvoie un " "mandataire pour cet objet." #: library/multiprocessing.rst:1837 msgid "" "Create a shared :class:`threading.Condition` object and return a proxy for " "it." msgstr "" "Crée un objet :class:`threading.Condition` partagé et renvoie un mandataire " "pour cet objet." #: library/multiprocessing.rst:1840 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`." #: library/multiprocessing.rst:1848 msgid "" "Create a shared :class:`threading.Event` object and return a proxy for it." msgstr "" "Crée un objet :class:`threading.Event` partagé et renvoie un mandataire pour " "cet objet." #: library/multiprocessing.rst:1852 msgid "" "Create a shared :class:`threading.Lock` object and return a proxy for it." msgstr "" "Crée un objet :class:`threading.Lock` partagé et renvoie un mandataire pour " "cet objet." #: library/multiprocessing.rst:1856 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." #: library/multiprocessing.rst:1860 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." #: library/multiprocessing.rst:1864 msgid "" "Create a shared :class:`threading.RLock` object and return a proxy for it." msgstr "" "Crée un objet :class:`threading.RLock` partagé et renvoie un mandataire pour " "cet objet." #: library/multiprocessing.rst:1868 msgid "" "Create a shared :class:`threading.Semaphore` object and return a proxy for " "it." msgstr "" "Crée un objet :class:`threading.Semaphore` partagé et renvoie un mandataire " "pour cet objet." #: library/multiprocessing.rst:1873 msgid "Create an array and return a proxy for it." msgstr "Crée un tableau et renvoie un mandataire pour cet objet." #: library/multiprocessing.rst:1877 msgid "" "Create an object with a writable ``value`` attribute and return a proxy for " "it." msgstr "" "Crée un objet avec un attribut ``value`` accessible en écriture et renvoie " "un mandataire pour cet objet." #: library/multiprocessing.rst:1884 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." #: library/multiprocessing.rst:1889 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." #: library/multiprocessing.rst:1891 msgid "" "Shared objects are capable of being nested. For example, a shared container " "object such as a shared list can contain other shared objects which will all " "be managed and synchronized by the :class:`SyncManager`." 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`." #: library/multiprocessing.rst:1898 msgid "A type that can register with :class:`SyncManager`." msgstr "Un type qui peut être enregistré avec :class:`SyncManager`." #: library/multiprocessing.rst:1900 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 nommage n'a pas de méthodes publiques, mais possède des " "attributs accessibles en écriture. Sa représentation montre les valeurs de " "ses attributs." #: library/multiprocessing.rst:1903 msgid "" "However, when using a proxy for a namespace object, an attribute beginning " "with ``'_'`` will be an attribute of the proxy and not an attribute of the " "referent:" msgstr "" "Cependant, en utilisant un mandataire pour un espace de nommage, un attribut " "débutant par ``'_'`` est un attribut du mandataire et non de l'objet cible :" #: library/multiprocessing.rst:1919 msgid "Customized managers" msgstr "Gestionnaires personnalisés" #: library/multiprocessing.rst:1921 msgid "" "To create one's own manager, one creates a subclass of :class:`BaseManager` " "and uses the :meth:`~BaseManager.register` classmethod to register new types " "or callables with the manager class. For example::" 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 ::" #: library/multiprocessing.rst:1946 msgid "Using a remote manager" msgstr "Utiliser un gestionnaire distant" #: library/multiprocessing.rst:1948 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)." #: library/multiprocessing.rst:1951 msgid "" "Running the following commands creates a server for a single shared queue " "which remote clients can access::" msgstr "" "Exécuter les commandes suivantes crée un serveur pour une file simple " "partagée à laquelle des clients distants peuvent accéder ::" #: library/multiprocessing.rst:1963 msgid "One client can access the server as follows::" msgstr "Un client peut accéder au serveur comme suit ::" #: library/multiprocessing.rst:1973 msgid "Another client can also use it::" msgstr "Un autre client peut aussi l'utiliser ::" #: library/multiprocessing.rst:1984 msgid "" "Local processes can also access that queue, using the code from above on the " "client to access it remotely::" msgstr "" "Les processus locaux peuvent aussi accéder à cette file, utilisant le code " "précédent sur le client pour y accéder à distance ::" #: library/multiprocessing.rst:2009 msgid "Proxy Objects" msgstr "Objets mandataires" #: library/multiprocessing.rst:2011 msgid "" "A proxy is an object which *refers* to a shared object which lives " "(presumably) in a different process. The shared object is said to be the " "*referent* of the proxy. Multiple proxy objects may have the same referent." 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." #: library/multiprocessing.rst:2015 msgid "" "A proxy object has methods which invoke corresponding methods of its " "referent (although not every method of the referent will necessarily be " "available through the proxy). In this way, a proxy can be used just like " "its referent can:" 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 :" #: library/multiprocessing.rst:2033 msgid "" "Notice that applying :func:`str` to a proxy will return the representation " "of the referent, whereas applying :func:`repr` will return the " "representation of the proxy." msgstr "" "Notez qu'appliquer :func:`str` à un mandataire renvoie la représentation du " "référent, alors que :func:`repr` renvoie celle du mandataire." #: library/multiprocessing.rst:2037 msgid "" "An important feature of proxy objects is that they are picklable so they can " "be passed between processes. As such, a referent can contain :ref:" "`multiprocessing-proxy_objects`. This permits nesting of these managed " "lists, dicts, and other :ref:`multiprocessing-proxy_objects`:" 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` :" #: library/multiprocessing.rst:2053 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 ::" #: library/multiprocessing.rst:2066 msgid "" "If standard (non-proxy) :class:`list` or :class:`dict` objects are contained " "in a referent, modifications to those mutable values will not be propagated " "through the manager because the proxy has no way of knowing when the values " "contained within are modified. However, storing a value in a container " "proxy (which triggers a ``__setitem__`` on the proxy object) does propagate " "through the manager and so to effectively modify such an item, one could re-" "assign the modified value to the container proxy::" msgstr "" "Si des objets standards (non *proxyfiés*) :class:`list` ou :class:`dict` " "sont contenus dans un référent, les modifications sur ces valeurs mutables " "ne seront pas propagées à travers le gestionnaire parce que le mandataire " "n'a aucun moyen de savoir quand les valeurs contenues sont modifiées. " "Cependant, stocker une valeur dans un conteneur mandataire (qui déclenche un " "appel à ``__setitem__`` sur le mandataire) propage bien la modification à " "travers le gestionnaire et modifie effectivement l'élément, il est ainsi " "possible de réassigner la valeur modifiée au conteneur mandataire ::" #: library/multiprocessing.rst:2085 msgid "" "This approach is perhaps less convenient than employing nested :ref:" "`multiprocessing-proxy_objects` for most use cases but also demonstrates a " "level of control over the synchronization." 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." #: library/multiprocessing.rst:2091 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 :" #: library/multiprocessing.rst:2099 msgid "" "One should just use a copy of the referent instead when making comparisons." msgstr "" "Il faut à la place simplement utiliser une copie du référent pour faire les " "comparaisons." #: library/multiprocessing.rst:2103 msgid "Proxy objects are instances of subclasses of :class:`BaseProxy`." msgstr "" "Les objets mandataires sont des instances de sous-classes de :class:" "`BaseProxy`." #: library/multiprocessing.rst:2107 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." #: library/multiprocessing.rst:2109 msgid "" "If ``proxy`` is a proxy whose referent is ``obj`` then the expression ::" msgstr "" "Si ``proxy`` est un mandataire sont le référent est ``obj``, alors " "l'expression ::" #: library/multiprocessing.rst:2113 msgid "will evaluate the expression ::" msgstr "s'évalue comme ::" #: library/multiprocessing.rst:2117 msgid "in the manager's process." msgstr "dans le processus du gestionnaire." #: library/multiprocessing.rst:2119 msgid "" "The returned value will be a copy of the result of the call or a proxy to a " "new shared object -- see documentation for the *method_to_typeid* argument " "of :meth:`BaseManager.register`." 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`." #: library/multiprocessing.rst:2123 msgid "" "If an exception is raised by the call, then is re-raised by :meth:" "`_callmethod`. If some other exception is raised in the manager's process " "then this is converted into a :exc:`RemoteError` exception and is raised by :" "meth:`_callmethod`." 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`." #: library/multiprocessing.rst:2128 msgid "" "Note in particular that an exception will be raised if *methodname* has not " "been *exposed*." msgstr "" "Notez en particulier qu'une exception est levée si *methodname* n'est pas " "*exposée*." #: library/multiprocessing.rst:2131 msgid "An example of the usage of :meth:`_callmethod`:" msgstr "Un exemple d'utilisation de :meth:`_callmethod` :" #: library/multiprocessing.rst:2147 msgid "Return a copy of the referent." msgstr "Renvoie une copie du référent." #: library/multiprocessing.rst:2149 msgid "If the referent is unpicklable then this will raise an exception." msgstr "Si le référent n'est pas sérialisable, une exception est levée." #: library/multiprocessing.rst:2153 msgid "Return a representation of the proxy object." msgstr "Renvoie la représentation de l'objet mandataire." #: library/multiprocessing.rst:2157 msgid "Return the representation of the referent." msgstr "Renvoie la représentation du référent." #: library/multiprocessing.rst:2161 msgid "Cleanup" msgstr "Nettoyage" #: library/multiprocessing.rst:2163 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." #: library/multiprocessing.rst:2166 msgid "" "A shared object gets deleted from the manager process when there are no " "longer any proxies referring to it." msgstr "" "Un objet partagé est supprimé par le processus gestionnaire quand plus aucun " "mandataire ne le référence." #: library/multiprocessing.rst:2171 msgid "Process Pools" msgstr "Pools de processus" #: library/multiprocessing.rst:2176 msgid "" "One can create a pool of processes which will carry out tasks submitted to " "it with the :class:`Pool` class." msgstr "" "On peut créer un pool de processus qui exécuteront les tâches qui lui seront " "soumises avec la classe :class:`Pool`." #: library/multiprocessing.rst:2181 msgid "" "A process pool object which controls a pool of worker processes to which " "jobs can be submitted. It supports asynchronous results with timeouts and " "callbacks and has a parallel map implementation." msgstr "" "Un objet *process pool* qui contrôle un pool de processus *workers* auquel " "sont soumises des tâches. Il supporte les résultats asynchrones avec des " "*timeouts* et des *callbacks* et possède une implémentation parallèle de " "*map*." #: library/multiprocessing.rst:2185 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é." #: library/multiprocessing.rst:2188 library/multiprocessing.rst:2749 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." #: library/multiprocessing.rst:2191 msgid "" "*maxtasksperchild* is the number of tasks a worker process can complete " "before it will exit and be replaced with a fresh worker process, to enable " "unused resources to be freed. The default *maxtasksperchild* is ``None``, " "which means worker processes will live as long as the pool." msgstr "" "*maxtasksperchild* est le nombre de tâches qu'un processus *worker* peut " "accomplir avant de se fermer et d'être remplacé par un *worker* frais, pour " "permettre aux ressources inutilisées d'être libérées. Par défaut " "*maxtasksperchild* est ``None``, ce qui signifie que le *worker* vit aussi " "longtemps que le pool." #: library/multiprocessing.rst:2196 msgid "" "*context* can be used to specify the context used for starting the worker " "processes. Usually a pool is created using the function :func:" "`multiprocessing.Pool` or the :meth:`Pool` method of a context object. In " "both cases *context* is set appropriately." msgstr "" "*context* peut être utilisé pour préciser le contexte utilisé pour démarrer " "les processus *workers*. Habituellement un pool est créé à l'aide de la " "fonction :func:`multiprocessing.Pool` ou de la méthode :meth:`Pool` d'un " "objet de contexte. Dans les deux cas *context* est réglé de façon appropriée." #: library/multiprocessing.rst:2202 msgid "" "Note that the methods of the pool object should only be called by the " "process which created the pool." msgstr "" "Notez que les méthodes de l'objet *pool* ne doivent être appelées que par le " "processus qui l'a créé." #: library/multiprocessing.rst:2206 msgid "" ":class:`multiprocessing.pool` objects have internal resources that need to " "be properly managed (like any other resource) by using the pool as a context " "manager or by calling :meth:`close` and :meth:`terminate` manually. Failure " "to do this can lead to the process hanging on finalization." msgstr "" "Les objets :class:`multiprocessing.pool` ont des ressources internes qui " "doivent être correctement gérées (comme toute autre ressource) en utilisant " "le pool comme gestionnaire de contexte ou en appelant :meth:`close` et :meth:" "`terminate` manuellement. Si cela n'est pas fait, le processus peut être " "bloqué à la finalisation." #: library/multiprocessing.rst:2211 msgid "" "Note that it is **not correct** to rely on the garbage collector to destroy " "the pool as CPython does not assure that the finalizer of the pool will be " "called (see :meth:`object.__del__` for more information)." msgstr "" "Notez qu'il n'est **pas** correct de compter sur le ramasse-miette pour " "détruire le pool car CPython ne garantit pas que le *finalizer* du pool est " "appelé (voir :meth:`object.__del__` pour plus d'informations)." #: library/multiprocessing.rst:2215 msgid "*maxtasksperchild*" msgstr "*maxtasksperchild*" #: library/multiprocessing.rst:2218 msgid "*context*" msgstr "*context*" #: library/multiprocessing.rst:2223 msgid "" "Worker processes within a :class:`Pool` typically live for the complete " "duration of the Pool's work queue. A frequent pattern found in other systems " "(such as Apache, mod_wsgi, etc) to free resources held by workers is to " "allow a worker within a pool to complete only a set amount of work before " "being exiting, being cleaned up and a new process spawned to replace the old " "one. The *maxtasksperchild* argument to the :class:`Pool` exposes this " "ability to the end user." msgstr "" "Les processus *workers* à l'intérieur d'une :class:`Pool` vivent par défaut " "aussi longtemps que la file de travail du pool. Un modèle fréquent chez " "d'autres systèmes (tels qu'Apache, *mod_wsgi*, etc.) pour libérer les " "ressources détenues par les *workers* est d'autoriser un *worker* dans le " "pool à accomplir seulement une certaine charge de travail avant de se " "fermer, se retrouvant nettoyé et remplacé par un nouveau processus " "fraîchement lancé. L'argument *maxtasksperchild* de :class:`Pool` expose " "cette fonctionnalité à l'utilisateur final." #: library/multiprocessing.rst:2233 msgid "" "Call *func* with arguments *args* and keyword arguments *kwds*. It blocks " "until the result is ready. Given this blocks, :meth:`apply_async` is better " "suited for performing work in parallel. Additionally, *func* is only " "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 pool." #: library/multiprocessing.rst:2240 msgid "" "A variant of the :meth:`apply` method which returns a :class:" "`~multiprocessing.pool.AsyncResult` object." msgstr "" "Une variante de la méthode :meth:`apply` qui renvoie un objet :class:" "`~multiprocessing.pool.AsyncResult`." #: library/multiprocessing.rst:2243 library/multiprocessing.rst:2274 msgid "" "If *callback* is specified then it should be a callable which accepts a " "single argument. When the result becomes ready *callback* is applied to it, " "that is unless the call failed, in which case the *error_callback* is " "applied instead." 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." #: library/multiprocessing.rst:2248 library/multiprocessing.rst:2279 msgid "" "If *error_callback* is specified then it should be a callable which accepts " "a single argument. If the target function fails, then the *error_callback* " "is called with the exception instance." 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." #: library/multiprocessing.rst:2252 library/multiprocessing.rst:2283 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é." #: library/multiprocessing.rst:2257 msgid "" "A parallel equivalent of the :func:`map` built-in function (it supports only " "one *iterable* argument though, for multiple iterables see :meth:`starmap`). " "It blocks until the result is ready." msgstr "" "Un équivalent parallèle de la fonction native :func:`map` (qui ne prend " "qu'un seul argument *itérable* ; pour en passer plusieurs, référez-vous à :" "meth:`starmap`). Elle bloque jusqu'à ce que le résultat soit prêt." #: library/multiprocessing.rst:2261 msgid "" "This method chops the iterable into a number of chunks which it submits to " "the process pool as separate tasks. The (approximate) size of these chunks " "can be specified by setting *chunksize* to a positive integer." msgstr "" "La méthode découpe l'itérable en un nombre de morceaux qu'elle envoie au " "pool de processus comme des tâches séparées. La taille (approximative) de " "ces morceaux peut être précisée en passant à *chunksize* un entier positif." #: library/multiprocessing.rst:2265 msgid "" "Note that it may cause high memory usage for very long iterables. Consider " "using :meth:`imap` or :meth:`imap_unordered` with explicit *chunksize* " "option for better efficiency." msgstr "" "Notez que cela peut entraîner une grosse consommation de mémoire pour les " "itérables très longs. Envisagez d'utiliser :meth:`imap` ou :meth:" "`imap_unordered` avec l'option *chunksize* explicite pour une meilleure " "efficacité." #: library/multiprocessing.rst:2271 msgid "" "A variant of the :meth:`.map` method which returns a :class:" "`~multiprocessing.pool.AsyncResult` object." msgstr "" "Une variante de la méthode :meth:`.map` qui renvoie un objet :class:" "`~multiprocessing.pool.AsyncResult`." #: library/multiprocessing.rst:2288 msgid "A lazier version of :meth:`.map`." msgstr "Une version paresseuse de :meth:`map`." #: library/multiprocessing.rst:2290 msgid "" "The *chunksize* argument is the same as the one used by the :meth:`.map` " "method. For very long iterables using a large value for *chunksize* can " "make the job complete **much** faster than using the default value of ``1``." 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``." #: library/multiprocessing.rst:2295 msgid "" "Also if *chunksize* is ``1`` then the :meth:`!next` method of the iterator " "returned by the :meth:`imap` method has an optional *timeout* parameter: " "``next(timeout)`` will raise :exc:`multiprocessing.TimeoutError` if the " "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." #: library/multiprocessing.rst:2302 msgid "" "The same as :meth:`imap` except that the ordering of the results from the " "returned iterator should be considered arbitrary. (Only when there is only " "one worker process is the order guaranteed to be \"correct\".)" 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*.)" #: library/multiprocessing.rst:2308 #, fuzzy msgid "" "Like :meth:`~multiprocessing.pool.Pool.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." #: library/multiprocessing.rst:2312 msgid "" "Hence an *iterable* of ``[(1,2), (3, 4)]`` results in ``[func(1,2), " "func(3,4)]``." msgstr "" "Par conséquent un *iterable* ``[(1,2), (3, 4)]`` donnera pour résultat " "``[func(1,2), func(3,4)]``." #: library/multiprocessing.rst:2319 msgid "" "A combination of :meth:`starmap` and :meth:`map_async` that iterates over " "*iterable* of iterables and calls *func* with the iterables unpacked. " "Returns a result object." 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." #: library/multiprocessing.rst:2327 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." #: library/multiprocessing.rst:2332 msgid "" "Stops the worker processes immediately without completing outstanding work. " "When the pool object is garbage collected :meth:`terminate` will be called " "immediately." msgstr "" "Stoppe immédiatement les processus *workers* sans finaliser les travaux " "courants. Quand l'objet *pool* est collecté par le ramasse-miettes, sa " "méthode :meth:`terminate` est appelée immédiatement." #: library/multiprocessing.rst:2338 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`." #: library/multiprocessing.rst:2341 msgid "" "Pool objects now support the context management protocol -- see :ref:" "`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the pool " "object, and :meth:`~contextmanager.__exit__` calls :meth:`terminate`." msgstr "" "Les pools de *workers* supportent maintenant le protocole des gestionnaires " "de contexte – voir :ref:`typecontextmanager`. :meth:`~contextmanager." "__enter__` renvoie l'objet *pool* et :meth:`~contextmanager.__exit__` " "appelle :meth:`terminate`." #: library/multiprocessing.rst:2349 msgid "" "The class of the result returned by :meth:`Pool.apply_async` and :meth:`Pool." "map_async`." msgstr "" "La classe des résultats renvoyés par :meth:`Pool.apply_async` et :meth:`Pool." "map_async`." #: library/multiprocessing.rst:2354 msgid "" "Return the result when it arrives. If *timeout* is not ``None`` and the " "result does not arrive within *timeout* seconds then :exc:`multiprocessing." "TimeoutError` is raised. If the remote call raised an exception then that " "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`." #: library/multiprocessing.rst:2361 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." #: library/multiprocessing.rst:2365 msgid "Return whether the call has completed." msgstr "Renvoie ``True`` ou ``False`` suivant si la tâche est accomplie." #: library/multiprocessing.rst:2369 msgid "" "Return whether the call completed without raising an exception. Will raise :" "exc:`ValueError` if the result is not ready." msgstr "" "Renvoie ``True`` ou ``False`` suivant si la tâche est accomplie sans lever " "d'exception. Lève une :exc:`ValueError` si le résultat n'est pas prêt." #: library/multiprocessing.rst:2372 msgid "" "If the result is not ready, :exc:`ValueError` is raised instead of :exc:" "`AssertionError`." msgstr "" "Si le résultat n'est pas prêt, une :exc:`ValueError` est levée au lieu " "d'une :exc:`AssertionError` auparavant." #: library/multiprocessing.rst:2376 msgid "The following example demonstrates the use of a pool::" msgstr "" "Les exemples suivants présentent l'utilisation d'un pool de *workers* ::" #: library/multiprocessing.rst:2403 msgid "Listeners and Clients" msgstr "Auditeurs et Clients" #: library/multiprocessing.rst:2408 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 files ou des objets :class:`~Connection` renvoyés par :func:" "`~multiprocessing.Pipe`." #: library/multiprocessing.rst:2412 msgid "" "However, the :mod:`multiprocessing.connection` module allows some extra " "flexibility. It basically gives a high level message oriented API for " "dealing with sockets or Windows named pipes. It also has support for " "*digest authentication* using the :mod:`hmac` module, and for polling " "multiple connections at the same time." msgstr "" "Cependant, le module :mod:`multiprocessing.connection` permet un peu plus de " "flexibilité. Il fournit un message de plus haut-niveau orienté API pour " "gérer des connecteurs ou des tubes nommés sous Windows. Il gère aussi " "l'authentification par condensat (*digest authentication* en anglais) en " "utilisant le module :mod:`hmac`, et pour interroger de multiples connexions " "en même temps." #: library/multiprocessing.rst:2421 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 extrémité de la connexion " "et attend une réponse." #: library/multiprocessing.rst:2424 msgid "" "If the reply matches the digest of the message using *authkey* as the key " "then a welcome message is sent to the other end of the connection. " "Otherwise :exc:`~multiprocessing.AuthenticationError` is raised." msgstr "" "Si la réponse correspond au condensat du message avec la clé *authkey*, " "alors un message de bienvenue est envoyé à l'autre extrémité de la " "connexion. Autrement, une :exc:`~multiprocessing.AuthenticationError` est " "levée." #: library/multiprocessing.rst:2430 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." #: library/multiprocessing.rst:2433 msgid "" "If a welcome message is not received, then :exc:`~multiprocessing." "AuthenticationError` is raised." msgstr "" "Si un message de bienvenue n'est pas reçu, une :exc:`~multiprocessing." "AuthenticationError` est levée." #: library/multiprocessing.rst:2438 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`." #: library/multiprocessing.rst:2441 msgid "" "The type of the connection is determined by *family* argument, but this can " "generally be omitted since it can usually be inferred from the format of " "*address*. (See :ref:`multiprocessing-address-formats`)" 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`)" #: library/multiprocessing.rst:2445 library/multiprocessing.rst:2480 msgid "" "If *authkey* is given and not None, it should be a byte string and will be " "used as the secret key for an HMAC-based authentication challenge. No " "authentication is done if *authkey* is None. :exc:`~multiprocessing." "AuthenticationError` is raised if authentication fails. See :ref:" "`multiprocessing-auth-keys`." msgstr "" "Si *authkey* est passée et n'est pas ``None``, elle doit être une chaîne " "d'octets et sera utilisée comme clé secrète pour le défi d'authentification " "basé sur HMAC. Aucune authentification n'est réalisée si *authkey* est " "``None``. Une :exc:`~multiprocessing.AuthenticationError` est levée si " "l'authentification échoue. Voir :ref:`multiprocessing-auth-keys`." #: library/multiprocessing.rst:2453 msgid "" "A wrapper for a bound socket or Windows named pipe which is 'listening' for " "connections." msgstr "" "Une enveloppe autour d'un connecteur lié ou un tube nommé sous Windows qui " "écoute pour des connexions." #: library/multiprocessing.rst:2456 msgid "" "*address* is the address to be used by the bound socket or named pipe of the " "listener object." msgstr "" "*address* est l'adresse à utiliser par le connecteur lié ou le tube nommé de " "l'objet auditeur." #: library/multiprocessing.rst:2461 msgid "" "If an address of '0.0.0.0' is used, the address will not be a connectable " "end point on Windows. If you require a connectable end-point, you should use " "'127.0.0.1'." 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'." #: library/multiprocessing.rst:2465 msgid "" "*family* is the type of socket (or named pipe) to use. This can be one of " "the strings ``'AF_INET'`` (for a TCP socket), ``'AF_UNIX'`` (for a Unix " "domain socket) or ``'AF_PIPE'`` (for a Windows named pipe). Of these only " "the first is guaranteed to be available. If *family* is ``None`` then the " "family is inferred from the format of *address*. If *address* is also " "``None`` then a default is chosen. This default is the family which is " "assumed to be the fastest available. See :ref:`multiprocessing-address-" "formats`. Note that if *family* is ``'AF_UNIX'`` and address is ``None`` " "then the socket will be created in a private temporary directory created " "using :func:`tempfile.mkstemp`." msgstr "" "*family* est le type de connecteur (ou tube nommé) à utiliser. Cela peut " "être l'une des chaînes ``'AF_INET'`` (pour un connecteur TCP), ``'AF_UNIX'`` " "(pour un connecteur Unix) ou ``'AF_PIPE'`` (pour un tube nommé sous " "Windows). Seulement le premier d'entre eux est garanti d'être disponible. Si " "*family* est ``None``, la famille est inférée depuis le format d'*address*. " "Si *address* est aussi ``None``, la famille par défaut est utilisée. La " "famille par défaut est supposée être la plus rapide disponible. Voir :ref:" "`multiprocessing-address-formats`. Notez que si la *family* est " "``'AF_UNIX'`` et qu'*address* est ``None``, le connecteur est créé dans un " "répertoire temporaire privé créé avec :func:`tempfile.mkstemp`." #: library/multiprocessing.rst:2476 msgid "" "If the listener object uses a socket then *backlog* (1 by default) is passed " "to the :meth:`~socket.socket.listen` method of the socket once it has been " "bound." msgstr "" "Si l'objet auditeur utilise un connecteur alors *backlog* (1 par défaut) est " "passé à la méthode :meth:`~socket.socket.listen` du connecteur une fois " "qu'il a été lié." #: library/multiprocessing.rst:2488 msgid "" "Accept a connection on the bound socket or named pipe of the listener object " "and return a :class:`~Connection` object. If authentication is attempted and " "fails, then :exc:`~multiprocessing.AuthenticationError` is raised." msgstr "" "Accepte une connexion sur le connecteur lié ou le tube nommé de l'objet " "auditeur et renvoie un objet :class:`~Connection`. Si la tentative " "d'authentification échoue, une :exc:`~multiprocessing.AuthenticationError` " "est levée." #: library/multiprocessing.rst:2495 msgid "" "Close the bound socket or named pipe of the listener object. This is called " "automatically when the listener is garbage collected. However it is " "advisable to call it explicitly." msgstr "" "Ferme le connecteur lié ou le tube nommé de l'objet auditeur. La méthode est " "appelée automatiquement quand l'auditeur est collecté par le ramasse-" "miettes. Il est cependant conseillé de l'appeler explicitement." #: library/multiprocessing.rst:2499 msgid "Listener objects have the following read-only properties:" msgstr "" "Les objets auditeurs ont aussi les propriétés en lecture seule suivantes :" #: library/multiprocessing.rst:2503 msgid "The address which is being used by the Listener object." msgstr "L'adresse utilisée par l'objet auditeur." #: library/multiprocessing.rst:2507 msgid "" "The address from which the last accepted connection came. If this is " "unavailable then it is ``None``." msgstr "" "L'adresse depuis laquelle a été établie la dernière connexion. ``None`` si " "aucune n'est disponible." #: library/multiprocessing.rst:2510 msgid "" "Listener objects now support the context management protocol -- see :ref:" "`typecontextmanager`. :meth:`~contextmanager.__enter__` returns the " "listener object, and :meth:`~contextmanager.__exit__` calls :meth:`close`." 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`." #: library/multiprocessing.rst:2517 msgid "" "Wait till an object in *object_list* is ready. Returns the list of those " "objects in *object_list* which are ready. If *timeout* is a float then the " "call blocks for at most that many seconds. If *timeout* is ``None`` then it " "will block for an unlimited period. A negative timeout is equivalent to a " "zero timeout." 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." #: library/multiprocessing.rst:2523 msgid "" "For both Unix and Windows, an object can appear in *object_list* if it is" msgstr "" "Pour Unix et Windows, un objet peut apparaître dans *object_list* s'il est" #: library/multiprocessing.rst:2526 msgid "a readable :class:`~multiprocessing.connection.Connection` object;" msgstr "" "un objet :class:`~multiprocessing.connection.Connection` accessible en " "lecture ;" #: library/multiprocessing.rst:2527 msgid "a connected and readable :class:`socket.socket` object; or" msgstr "un objet :class:`socket.socket` connecté et accessible en lecture ; ou" #: library/multiprocessing.rst:2528 msgid "" "the :attr:`~multiprocessing.Process.sentinel` attribute of a :class:" "`~multiprocessing.Process` object." msgstr "" "l'attribut :attr:`~multiprocessing.Process.sentinel` d'un objet :class:" "`~multiprocessing.Process`." #: library/multiprocessing.rst:2531 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 (*socket* en anglais) est prête quand il y a des données " "disponibles en lecture dessus, ou que l'autre extrémité a été fermée." #: library/multiprocessing.rst:2534 msgid "" "**Unix**: ``wait(object_list, timeout)`` almost equivalent ``select." "select(object_list, [], [], timeout)``. The difference is that, if :func:" "`select.select` is interrupted by a signal, it can raise :exc:`OSError` with " "an error number of ``EINTR``, whereas :func:`wait` will not." 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." #: library/multiprocessing.rst:2540 msgid "" "**Windows**: An item in *object_list* must either be an integer handle which " "is waitable (according to the definition used by the documentation of the " "Win32 function ``WaitForMultipleObjects()``) or it can be an object with a :" "meth:`fileno` method which returns a socket handle or pipe handle. (Note " "that pipe handles and socket handles are **not** waitable handles.)" msgstr "" "**Windows** : un élément d'*object_list* doit être soit un identifiant " "*waitable* (en accord avec la définition utilisée par la documentation de la " "fonction Win32 ``WaitForMultipleObjects()``), soit un objet avec une " "méthode :meth:`fileno` qui renvoie un identifiant de connecteur ou de tube " "(notez que les identifiants de tubes et de connecteurs **ne sont pas** des " "identifiants *waitables*)." #: library/multiprocessing.rst:2550 msgid "**Examples**" msgstr "**Exemples**" #: library/multiprocessing.rst:2552 msgid "" "The following server code creates a listener which uses ``'secret " "password'`` as an authentication key. It then waits for a connection and " "sends some data to the client::" 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 ::" #: library/multiprocessing.rst:2571 msgid "" "The following code connects to the server and receives some data from the " "server::" msgstr "Le code suivant se connecte au serveur et en reçoit des données ::" #: library/multiprocessing.rst:2588 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 ::" #: library/multiprocessing.rst:2627 msgid "Address Formats" msgstr "Formats d'adresses" #: library/multiprocessing.rst:2629 msgid "" "An ``'AF_INET'`` address is a tuple of the form ``(hostname, port)`` where " "*hostname* is a string and *port* is an integer." msgstr "" "une adresse ``'AF_INET'`` est une paire de la forme ``(hostname, port)`` où " "*hostname* est une chaîne et *port* un entier ;" #: library/multiprocessing.rst:2632 msgid "" "An ``'AF_UNIX'`` address is a string representing a filename on the " "filesystem." msgstr "" "une adresse ``'AF_UNIX'`` est une chaîne représentant un nom de fichier sur " "le système de fichiers ;" #: library/multiprocessing.rst:2635 #, fuzzy msgid "" "An ``'AF_PIPE'`` address is a string of the form :samp:`r'\\\\\\\\\\\\.\\" "\\pipe\\\\\\\\{PipeName}'`. To use :func:`Client` to connect to a named " "pipe on a remote computer called *ServerName* one should use an address of " "the form :samp:`r'\\\\\\\\\\\\\\\\{ServerName}\\\\pipe\\\\\\\\{PipeName}'` " "instead." msgstr "" "une adresse ``'AF_PIPE'`` est une chaîne de caractères de la forme :samp:" "`r'\\\\\\\\.\\\\pipe\\\\{NomDuTube}'`. Pour utiliser :func:`Client` pour se " "connecter à un tube nommé sur une machine distante appelée *NomDeLaMachine*, " "il faut utiliser une adresse de la forme :samp:`r'\\\\\\\\{NomDeLaMachine}\\" "\\pipe\\\\{NomDuTube}'`." #: library/multiprocessing.rst:2640 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'``." #: library/multiprocessing.rst:2647 msgid "Authentication keys" msgstr "Clés d'authentification" #: library/multiprocessing.rst:2649 msgid "" "When one uses :meth:`Connection.recv `, the data received " "is automatically unpickled. Unfortunately unpickling data from an untrusted " "source is a security risk. Therefore :class:`Listener` and :func:`Client` " "use the :mod:`hmac` module to provide digest authentication." 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." #: library/multiprocessing.rst:2655 msgid "" "An authentication key is a byte string which can be thought of as a " "password: once a connection is established both ends will demand proof that " "the other knows the authentication key. (Demonstrating that both ends are " "using the same key does **not** involve sending the key over the connection.)" 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.)" #: library/multiprocessing.rst:2661 msgid "" "If authentication is requested but no authentication key is specified then " "the return value of ``current_process().authkey`` is used (see :class:" "`~multiprocessing.Process`). This value will be automatically inherited by " "any :class:`~multiprocessing.Process` object that the current process " "creates. This means that (by default) all processes of a multi-process " "program will share a single authentication key which can be used when " "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." #: library/multiprocessing.rst:2669 msgid "" "Suitable authentication keys can also be generated by using :func:`os." "urandom`." msgstr "" "Des clés d'authentification adaptées peuvent aussi être générées par :func:" "`os.urandom`." #: library/multiprocessing.rst:2673 msgid "Logging" msgstr "Journalisation" #: library/multiprocessing.rst:2675 msgid "" "Some support for logging is available. Note, however, that the :mod:" "`logging` package does not use process shared locks so it is possible " "(depending on the handler type) for messages from different processes to get " "mixed up." 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." #: library/multiprocessing.rst:2682 msgid "" "Returns the logger used by :mod:`multiprocessing`. If necessary, a new one " "will be created." msgstr "" "Renvoie le journaliseur utilisé par :mod:`multiprocessing`. Si nécessaire, " "un nouveau sera créé." #: library/multiprocessing.rst:2685 msgid "" "When first created the logger has level :data:`logging.NOTSET` and no " "default handler. Messages sent to this logger will not by default propagate " "to the root logger." 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." #: library/multiprocessing.rst:2689 msgid "" "Note that on Windows child processes will only inherit the level of the " "parent process's logger -- any other customization of the logger will not be " "inherited." 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." #: library/multiprocessing.rst:2696 #, fuzzy msgid "" "This function performs a call to :func:`get_logger` but in addition to " "returning the logger created by get_logger, it adds a handler which sends " "output to :data:`sys.stderr` using format ``'[%(levelname)s/%(processName)s] " "%(message)s'``. You can modify ``levelname`` of the logger by passing a " "``level`` argument." 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'``." #: library/multiprocessing.rst:2702 msgid "Below is an example session with logging turned on::" msgstr "" "L'exemple ci-dessous présente une session avec la journalisation activée ::" #: library/multiprocessing.rst:2717 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`." #: library/multiprocessing.rst:2721 msgid "The :mod:`multiprocessing.dummy` module" msgstr "Le module :mod:`multiprocessing.dummy`" #: library/multiprocessing.rst:2726 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'une interface autour du module :mod:`threading`." #: library/multiprocessing.rst:2731 msgid "" "In particular, the ``Pool`` function provided by :mod:`multiprocessing." "dummy` returns an instance of :class:`ThreadPool`, which is a subclass of :" "class:`Pool` that supports all the same method calls but uses a pool of " "worker threads rather than worker processes." msgstr "" "En particulier, la fonction ``Pool`` du module :mod:`multiprocessing.dummy` " "renvoie une instance de :class:`ThreadPool`, qui est une sous-classe de :" "class:`Pool`. Elle a la même interface, mais elle utilise un pool de fils " "d'exécution plutôt qu'un pool de processus." #: library/multiprocessing.rst:2739 msgid "" "A thread pool object which controls a pool of worker threads to which jobs " "can be submitted. :class:`ThreadPool` instances are fully interface " "compatible with :class:`Pool` instances, and their resources must also be " "properly managed, either by using the pool as a context manager or by " "calling :meth:`~multiprocessing.pool.Pool.close` and :meth:`~multiprocessing." "pool.Pool.terminate` manually." msgstr "" "Un objet qui contrôle un pool de fils d'exécution auquel des tâches peuvent " "être envoyées. L'interface des instances de :class:`ThreadPool` est " "entièrement compatible avec celle des instances de :class:`Pool`, et leur " "ressources doivent être aussi correctement gérées, soit en utilisant le pool " "avec un contexte, soit en appelant explicitement :meth:`~multiprocessing." "pool.Pool.close` et :meth:`~multiprocessing.pool.Pool.terminate`." #: library/multiprocessing.rst:2746 msgid "" "*processes* is the number of worker threads to use. If *processes* is " "``None`` then the number returned by :func:`os.cpu_count` is used." msgstr "" "*processes* est le nombre de fils d'exécution à utiliser. Si *processes* est " "``None``, le nombre renvoyé par :func:`os.cpu_count` est utilisé." #: library/multiprocessing.rst:2752 msgid "" "Unlike :class:`Pool`, *maxtasksperchild* and *context* cannot be provided." msgstr "" "À la différence de :class:`Pool`, *maxtasksperchild* et *context* ne peuvent " "pas être passés en arguments." #: library/multiprocessing.rst:2756 msgid "" "A :class:`ThreadPool` shares the same interface as :class:`Pool`, which is " "designed around a pool of processes and predates the introduction of the :" "class:`concurrent.futures` module. As such, it inherits some operations " "that don't make sense for a pool backed by threads, and it has its own type " "for representing the status of asynchronous jobs, :class:`AsyncResult`, that " "is not understood by any other libraries." msgstr "" "La classe :class:`ThreadPool` a la même interface que la classe :class:" "`Pool`, dont l'implémentation repose sur un pool de processus, et a été " "introduite avant le module :class:`concurrent.futures`. Par conséquent elle " "implémente des opérations qui n'ont pas vraiment de sens pour un pool " "implémenté avec des fils d'exécution et possède son propre type pour " "représenter le statut de tâches asynchrones, :class:`AsyncResult`, qui n'est " "pas géré par les autres modules." #: library/multiprocessing.rst:2763 msgid "" "Users should generally prefer to use :class:`concurrent.futures." "ThreadPoolExecutor`, which has a simpler interface that was designed around " "threads from the start, and which returns :class:`concurrent.futures.Future` " "instances that are compatible with many other libraries, including :mod:" "`asyncio`." msgstr "" "Il est souvent plus judicieux d'utiliser :class:`concurrent.futures." "ThreadPoolExecutor` qui a une interface plus simple, qui a été pensée dès " "l'origine pour les fils d'exécution et qui renvoie des instances de :class:" "`concurrent.futures.Future` qui sont compatibles avec de nombreux modules, " "dont :mod:`asyncio`." #: library/multiprocessing.rst:2773 msgid "Programming guidelines" msgstr "Lignes directrices de programmation" #: library/multiprocessing.rst:2775 msgid "" "There are certain guidelines and idioms which should be adhered to when " "using :mod:`multiprocessing`." msgstr "" "Il y a certaines lignes directrices et idiomes à respecter pour utiliser :" "mod:`multiprocessing`." #: library/multiprocessing.rst:2780 msgid "All start methods" msgstr "Toutes les méthodes de démarrage" #: library/multiprocessing.rst:2782 msgid "The following applies to all start methods." msgstr "Les règles suivantes s'appliquent aux méthodes de démarrage." #: library/multiprocessing.rst:2784 msgid "Avoid shared state" msgstr "Éviter les états partagés" #: library/multiprocessing.rst:2786 msgid "" "As far as possible one should try to avoid shifting large amounts of data " "between processes." msgstr "" "Autant que possible, il faut éviter de transférer de gros volumes de données " "entre les processus." #: library/multiprocessing.rst:2789 msgid "" "It is probably best to stick to using queues or pipes for communication " "between processes rather than using the lower level synchronization " "primitives." msgstr "" "Il est souvent plus judicieux de se borner à utiliser des files et des tubes " "pour gérer la communication entre processus plutôt que d'utiliser des " "primitives de synchronisation plus bas-niveau." #: library/multiprocessing.rst:2793 msgid "Picklability" msgstr "Sérialisation" #: library/multiprocessing.rst:2795 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*)." #: library/multiprocessing.rst:2797 msgid "Thread safety of proxies" msgstr "Sûreté des mandataires à travers les fils d'exécution" #: library/multiprocessing.rst:2799 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." #: library/multiprocessing.rst:2802 msgid "" "(There is never a problem with different processes using the *same* proxy.)" msgstr "" "Il n'y a jamais de problème à avoir plusieurs processus qui utilisent un " "*même* mandataire." #: library/multiprocessing.rst:2804 msgid "Joining zombie processes" msgstr "Attendre les processus zombies" #: library/multiprocessing.rst:2806 msgid "" "On Unix when a process finishes but has not been joined it becomes a zombie. " "There should never be very many because each time a new process starts (or :" "func:`~multiprocessing.active_children` is called) all completed processes " "which have not yet been joined will be joined. Also calling a finished " "process's :meth:`Process.is_alive ` will " "join the process. Even so it is probably good practice to explicitly join " "all the processes that you start." msgstr "" "Sous Unix quand un processus se termine mais n'est pas attendu, il devient " "un zombie. Il ne devrait jamais y en avoir beaucoup parce que chaque fois " "qu'un nouveau processus démarre (ou que :func:`~multiprocessing." "active_children` est appelée) tous les processus complétés qui n'ont pas été " "attendus le sont alors. Appeler la méthode :meth:`Process.is_alive " "` d'un processus terminé attend aussi le " "processus. Toutefois, il est, en règle générale, conseillé d'attendre " "explicitement tous les processus que vous démarrez." #: library/multiprocessing.rst:2814 msgid "Better to inherit than pickle/unpickle" msgstr "Mieux vaut hériter que sérialiser - désérialiser" #: library/multiprocessing.rst:2816 msgid "" "When using the *spawn* or *forkserver* start methods many types from :mod:" "`multiprocessing` need to be picklable so that child processes can use " "them. However, one should generally avoid sending shared objects to other " "processes using pipes or queues. Instead you should arrange the program so " "that a process which needs access to a shared resource created elsewhere can " "inherit it from an ancestor process." msgstr "" "Quand vous utilisez les méthodes de démarrage *spawn* ou *forkserver*, de " "nombreux types de :mod:`multiprocessing` nécessitent d'être sérialisés pour " "que les processus fils puissent les utiliser. Cependant, il faut " "généralement éviter d'envoyer des objets partagés aux autres processus en " "utilisant des tubes ou des files. Vous devez plutôt vous arranger pour qu'un " "processus qui nécessite l'accès à une ressource partagée créée autre part " "qu'il en hérite depuis un de ses processus ancêtres." #: library/multiprocessing.rst:2824 msgid "Avoid terminating processes" msgstr "Éviter de terminer les processus" #: library/multiprocessing.rst:2826 msgid "" "Using the :meth:`Process.terminate ` " "method to stop a process is liable to cause any shared resources (such as " "locks, semaphores, pipes and queues) currently being used by the process to " "become broken or unavailable to other processes." msgstr "" "Utiliser la méthode :meth:`Process.terminate ` pour stopper un processus risque de casser ou de rendre " "indisponible aux autres processus des ressources partagées (comme des " "verrous, sémaphores, tubes et files) actuellement utilisées par le processus." #: library/multiprocessing.rst:2832 msgid "" "Therefore it is probably best to only consider using :meth:`Process." "terminate ` on processes which never use " "any shared resources." msgstr "" "Il est donc préférable de n'utiliser :meth:`Process.terminate " "` que sur les processus qui n'utilisent " "jamais de ressources partagées." #: library/multiprocessing.rst:2836 msgid "Joining processes that use queues" msgstr "Attendre les processus qui utilisent des files" #: library/multiprocessing.rst:2838 msgid "" "Bear in mind that a process that has put items in a queue will wait before " "terminating until all the buffered items are fed by the \"feeder\" thread to " "the underlying pipe. (The child process can call the :meth:`Queue." "cancel_join_thread ` method of the " "queue to avoid this behaviour.)" msgstr "" "Gardez à l'esprit qu'un processus qui a placé des éléments dans une file " "attend que tous les éléments mis en tampon soient consommés par le fil " "d'exécution « chargeur » du tube sous-jacent avant de se terminer (le " "processus fils peut appeler la méthode :meth:`Queue.cancel_join_thread " "` de la queue pour éviter ce " "comportement)." #: library/multiprocessing.rst:2844 msgid "" "This means that whenever you use a queue you need to make sure that all " "items which have been put on the queue will eventually be removed before the " "process is joined. Otherwise you cannot be sure that processes which have " "put items on the queue will terminate. Remember also that non-daemonic " "processes will be joined automatically." msgstr "" "Cela signifie que chaque fois que vous utilisez une file, vous devez vous " "assurer que tous les éléments qui y ont été placés ont été effectivement " "supprimés avant que le processus ne soit attendu. Autrement vous ne pouvez " "pas être sûr que les processus qui ont placé des éléments dans la file se " "termineront. Souvenez-vous aussi que tous les processus non *daemons* sont " "attendus automatiquement." #: library/multiprocessing.rst:2850 msgid "An example which will deadlock is the following::" msgstr "L'exemple suivant provoque un interblocage ::" #: library/multiprocessing.rst:2864 msgid "" "A fix here would be to swap the last two lines (or simply remove the ``p." "join()`` line)." msgstr "" "Une solution ici consiste à intervertir les deux dernières lignes (ou " "simplement à supprimer la ligne ``p.join()``)." #: library/multiprocessing.rst:2867 msgid "Explicitly pass resources to child processes" msgstr "Passer explicitement les ressources aux processus fils" #: library/multiprocessing.rst:2869 msgid "" "On Unix using the *fork* start method, a child process can make use of a " "shared resource created in a parent process using a global resource. " "However, it is better to pass the object as an argument to the constructor " "for the child process." 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." #: library/multiprocessing.rst:2874 msgid "" "Apart from making the code (potentially) compatible with Windows and the " "other start methods this also ensures that as long as the child process is " "still alive the object will not be garbage collected in the parent process. " "This might be important if some resource is freed when the object is garbage " "collected in the parent process." 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." #: library/multiprocessing.rst:2881 msgid "So for instance ::" msgstr "Donc par exemple ::" #: library/multiprocessing.rst:2893 msgid "should be rewritten as ::" msgstr "devrait être réécrit comme ::" #: library/multiprocessing.rst:2905 msgid "Beware of replacing :data:`sys.stdin` with a \"file like object\"" msgstr "" "Faire attention à remplacer :data:`sys.stdin` par un objet simili-fichier" #: library/multiprocessing.rst:2907 msgid ":mod:`multiprocessing` originally unconditionally called::" msgstr "À l'origine, :mod:`multiprocessing` appelait inconditionnellement ::" #: library/multiprocessing.rst:2911 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 ::" #: library/multiprocessing.rst:2917 msgid "" "Which solves the fundamental issue of processes colliding with each other " "resulting in a bad file descriptor error, but introduces a potential danger " "to applications which replace :func:`sys.stdin` with a \"file-like object\" " "with output buffering. This danger is that if multiple processes call :meth:" "`~io.IOBase.close()` on this file-like object, it could result in the same " "data being flushed to the object multiple times, resulting in corruption." msgstr "" "Qui résout le problème fondamental des collisions entre processus provoquant " "des erreurs de mauvais descripteurs de fichiers, mais introduit un potentiel " "danger pour les applications qui remplacent :func:`sys.stdin` avec un objet " "simili-fichier ayant une sortie mise en tampon. Ce danger est que si " "plusieurs processus appellent :meth:`~io.IOBase.close()` sur cet objet, cela " "peut amener les données à être transmises à l'objet à plusieurs reprises, " "résultant en une corruption." #: library/multiprocessing.rst:2924 msgid "" "If you write a file-like object and implement your own caching, you can make " "it fork-safe by storing the pid whenever you append to the cache, and " "discarding the cache when the pid changes. For example::" msgstr "" "Si vous écrivez un objet simili-fichier et implémentez votre propre cache, " "vous pouvez le rendre sûr pour les *forks* en stockant le *pid* chaque fois " "que vous ajoutez des données au cache, et annulez le cache quand le *pid* " "change. Par exemple ::" #: library/multiprocessing.rst:2936 msgid "" "For more information, see :issue:`5155`, :issue:`5313` and :issue:`5331`" msgstr "" "Pour plus d'informations, voir :issue:`5155`, :issue:`5313` et :issue:`5331`" #: library/multiprocessing.rst:2939 msgid "The *spawn* and *forkserver* start methods" msgstr "Les méthodes de démarrage *spawn* et *forkserver*" #: library/multiprocessing.rst:2941 msgid "" "There are a few extra restriction which don't apply to the *fork* start " "method." msgstr "" "Certaines restrictions ne s'appliquent pas à la méthode de démarrage *fork*." #: library/multiprocessing.rst:2944 msgid "More picklability" msgstr "Contraintes supplémentaires sur la sérialisation" #: library/multiprocessing.rst:2946 msgid "" "Ensure that all arguments to :meth:`Process.__init__` are picklable. Also, " "if you subclass :class:`~multiprocessing.Process` then make sure that " "instances will be picklable when the :meth:`Process.start ` method is called." 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." #: library/multiprocessing.rst:2951 msgid "Global variables" msgstr "Variables globales" #: library/multiprocessing.rst:2953 msgid "" "Bear in mind that if code run in a child process tries to access a global " "variable, then the value it sees (if any) may not be the same as the value " "in the parent process at the time that :meth:`Process.start ` was called." 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." #: library/multiprocessing.rst:2958 msgid "" "However, global variables which are just module level constants cause no " "problems." msgstr "" "Cependant, les variables globales qui sont juste des constantes de modules " "ne posent pas de problèmes." #: library/multiprocessing.rst:2963 msgid "Safe importing of main module" msgstr "Importation sécurisée du module principal" #: library/multiprocessing.rst:2965 msgid "" "Make sure that the main module can be safely imported by a new Python " "interpreter without causing unintended side effects (such a starting a new " "process)." 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)." #: library/multiprocessing.rst:2969 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` ::" #: library/multiprocessing.rst:2981 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 ::" #: library/multiprocessing.rst:2995 msgid "" "(The ``freeze_support()`` line can be omitted if the program will be run " "normally instead of frozen.)" msgstr "" "(La ligne ``freeze_support()`` peut être omise si le programme est " "uniquement lancé normalement et pas figé.)" #: library/multiprocessing.rst:2998 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()``." #: library/multiprocessing.rst:3001 msgid "" "Similar restrictions apply if a pool or manager is created in the main " "module." msgstr "" "Des restrictions similaires s'appliquent si un pool ou un gestionnaire est " "créé dans le module principal." #: library/multiprocessing.rst:3008 msgid "Examples" msgstr "Exemples" #: library/multiprocessing.rst:3010 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 :" #: library/multiprocessing.rst:3016 msgid "Using :class:`~multiprocessing.pool.Pool`:" msgstr "En utilisant :class:`~multiprocessing.pool.Pool` :" #: library/multiprocessing.rst:3022 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 files pour alimenter en tâches une " "collection de processus *workers* et collecter les résultats :" #~ 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'``." #~ msgid "By default, no arguments are passed to *target*." #~ msgstr "Par défaut, aucun argument n'est passé à *target*." #~ msgid "May raise :exc:`NotImplementedError`." #~ msgstr "Peut lever une :exc:`NotImplementedError`." #~ msgid "An ``'AF_PIPE'`` address is a string of the form" #~ msgstr "Une adresse ``'AF_PIPE'`` est une chaîne de la forme"