python-docs-fr/library/threading.po

# Copyright (C) 2001-2018, Python Software Foundation
# For licence information, see README file.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2020-10-01 16:00+0200\n"
"PO-Revision-Date: 2020-03-29 11:56+0200\n"
"Last-Translator: Mathieu Dupuy <deronnax@gmail.com>\n"
"Language-Team: FRENCH <traductions@lists.afpy.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: Poedit 2.3\n"

#: library/threading.rst:2
msgid ":mod:`threading` --- Thread-based parallelism"
msgstr ""
":mod:`threading` — Parallélisme basé sur les fils d’exécution (*threads*)"

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

#: library/threading.rst:11
msgid ""
"This module constructs higher-level threading interfaces on top of the lower "
"level :mod:`_thread` module.  See also the :mod:`queue` module."
msgstr ""
"Ce module élabore des interfaces haut-niveau de fils d'exécutions multiples "
"(*threading*) conçues en s'appuyant sur le module bas-niveau :mod:`_thread`. "
"Voir aussi le module :mod:`queue`."

#: library/threading.rst:14
msgid "This module used to be optional, it is now always available."
msgstr ""
"Ce module était auparavant optionnel, il est maintenant toujours disponible."

#: library/threading.rst:19
msgid ""
"While they are not listed below, the ``camelCase`` names used for some "
"methods and functions in this module in the Python 2.x series are still "
"supported by this module."
msgstr ""
"Bien qu'ils ne soient pas listés ci-dessous, ce module gère toujours les "
"noms en ``camelCase`` utilisés pour certaines méthodes et fonctions de ce "
"module dans la série Python 2.x."

#: library/threading.rst:24
msgid "This module defines the following functions:"
msgstr "Ce module définit les fonctions suivantes :"

#: library/threading.rst:29
msgid ""
"Return the number of :class:`Thread` objects currently alive.  The returned "
"count is equal to the length of the list returned by :func:`.enumerate`."
msgstr ""
"Renvoie le nombre d'objets :class:`Thread` actuellement vivants. Le compte "
"renvoyé est égal à la longueur de la liste renvoyée par :func:`.enumerate`."

#: library/threading.rst:35
msgid ""
"Return the current :class:`Thread` object, corresponding to the caller's "
"thread of control.  If the caller's thread of control was not created "
"through the :mod:`threading` module, a dummy thread object with limited "
"functionality is returned."
msgstr ""
"Renvoie l'objet :class:`Thread` courant, correspondant au fil de contrôle de "
"l'appelant. Si le fil de contrôle de l'appelant n'a pas été créé via le "
"module :mod:`Thread`, un objet *thread* factice aux fonctionnalités limitées "
"est renvoyé."

#: library/threading.rst:43
msgid "Handle uncaught exception raised by :func:`Thread.run`."
msgstr "Gère les exceptions non-attrapées levées par :func:`Thread.run`."

#: library/threading.rst:45
msgid "The *args* argument has the following attributes:"
msgstr "L'argument *arg* a les attributs suivants :"

#: library/threading.rst:47
msgid "*exc_type*: Exception type."
msgstr "*exc_type* : le type de l'exception ;"

#: library/threading.rst:48
msgid "*exc_value*: Exception value, can be ``None``."
msgstr "*exc_value*: la valeur de l'exception, peut être ``None`` ;"

#: library/threading.rst:49
msgid "*exc_traceback*: Exception traceback, can be ``None``."
msgstr ""
"*exc_traceback* : la pile d'appels pour cette exception, peut être ``None`` ;"

#: library/threading.rst:50
msgid "*thread*: Thread which raised the exception, can be ``None``."
msgstr ""
"*thread*: le fil d'exécution ayant levé l'exception, peut être ``None``."

#: library/threading.rst:52
msgid ""
"If *exc_type* is :exc:`SystemExit`, the exception is silently ignored. "
"Otherwise, the exception is printed out on :data:`sys.stderr`."
msgstr ""
"Si *exc_type* est :exc:`SystemExit`, l'exception est ignorée "
"silencieusement. Toutes les autres sont affichées sur :data:`sys.stderr`."

#: library/threading.rst:55
msgid ""
"If  this function raises an exception, :func:`sys.excepthook` is called to "
"handle it."
msgstr ""
"Si cette fonction lève une exception, :func:`sys.excepthook` est appelée "
"pour la gérer."

#: library/threading.rst:58
msgid ""
":func:`threading.excepthook` can be overridden to control how uncaught "
"exceptions raised by :func:`Thread.run` are handled."
msgstr ""
"La fonction :func:`threading.excepthook` peut être surchargée afin de "
"contrôler comment les exceptions non-attrapées levées par :func:`Thread.run` "
"sont gérées."

#: library/threading.rst:61
msgid ""
"Storing *exc_value* using a custom hook can create a reference cycle. It "
"should be cleared explicitly to break the reference cycle when the exception "
"is no longer needed."
msgstr ""
"Stocker *exc_value* en utilisant une fonction de rappel personnalisée peut "
"créer un cycle de références. *exc_value* doit être nettoyée explicitement "
"pour casser ce cycle lorsque l'exception n'est plus nécessaire."

#: library/threading.rst:65
msgid ""
"Storing *thread* using a custom hook can resurrect it if it is set to an "
"object which is being finalized. Avoid storing *thread* after the custom "
"hook completes to avoid resurrecting objects."
msgstr ""
"Stocker *thread* en utilisant une fonction de rappel personnalisée peut le "
"ressusciter, si c'est un objet en cours de finalisation. Évitez de stocker "
"*thread* après la fin de la fonction de rappel, pour éviter de ressusciter "
"des objets."

#: library/threading.rst:70
msgid ":func:`sys.excepthook` handles uncaught exceptions."
msgstr ""
":func:`sys.excepthook` gère les exceptions qui n'ont pas été attrapées."

#: library/threading.rst:77
msgid ""
"Return the 'thread identifier' of the current thread.  This is a nonzero "
"integer.  Its value has no direct meaning; it is intended as a magic cookie "
"to be used e.g. to index a dictionary of thread-specific data.  Thread "
"identifiers may be recycled when a thread exits and another thread is "
"created."
msgstr ""
"Renvoie l'« identifiant de fil »  du fil d'exécution courant. C'est un "
"entier non nul. Sa valeur n'a pas de signification directe ; il est destiné "
"à être utilisé comme valeur magique opaque, par exemple comme clef de "
"dictionnaire de données pour chaque fil. Les identificateurs de fils peuvent "
"être recyclés lorsqu'un fil se termine et qu'un autre fil est créé."

#: library/threading.rst:88
msgid ""
"Return the native integral Thread ID of the current thread assigned by the "
"kernel. This is a non-negative integer. Its value may be used to uniquely "
"identify this particular thread system-wide (until the thread terminates, "
"after which the value may be recycled by the OS)."
msgstr ""
"Renvoie l'identifiant natif complet assigné par le noyau du fil d'exécution "
"actuel. C'est un entier non négatif. Sa valeur peut uniquement être utilisée "
"pour identifier ce fil d'exécution à l'échelle du système (jusqu'à ce que le "
"fil d'exécution se termine, après quoi la valeur peut être recyclée par le "
"système d'exploitation)."

#: library/threading.rst:94
msgid ""
":ref:`Availability <availability>`: Windows, FreeBSD, Linux, macOS, OpenBSD, "
"NetBSD, AIX."
msgstr ""
":ref:`Disponibilité <availability>` : Windows, FreeBSD, Linux, macOS, "
"OpenBSD, NetBSD, AIX."

#: library/threading.rst:100
msgid ""
"Return a list of all :class:`Thread` objects currently alive.  The list "
"includes daemonic threads, dummy thread objects created by :func:"
"`current_thread`, and the main thread.  It excludes terminated threads and "
"threads that have not yet been started."
msgstr ""
"Renvoie une liste de tous les objets fil d'exécution :class:`Thread` "
"actuellement vivants. La liste inclut les fils démons, les fils factices "
"créés par :func:`current_thread` et le fil principal.  Elle exclut les fils "
"terminés et les fils qui n'ont pas encore été lancés."

#: library/threading.rst:108
msgid ""
"Return the main :class:`Thread` object.  In normal conditions, the main "
"thread is the thread from which the Python interpreter was started."
msgstr ""
"Renvoie l'objet fil d'exécution :class:`Thread` principal. Dans des "
"conditions normales, le fil principal est le fil à partir duquel "
"l'interpréteur Python a été lancé."

#: library/threading.rst:119
msgid ""
"Set a trace function for all threads started from the :mod:`threading` "
"module. The *func* will be passed to  :func:`sys.settrace` for each thread, "
"before its :meth:`~Thread.run` method is called."
msgstr ""
"Attache une fonction de traçage pour tous les fils d'exécution démarrés "
"depuis le module :mod:`Thread`. La fonction *func* est passée à :func:`sys."
"settrace` pour chaque fil, avant que sa méthode :meth:`~Thread.run` soit "
"appelée."

#: library/threading.rst:128
msgid ""
"Set a profile function for all threads started from the :mod:`threading` "
"module. The *func* will be passed to  :func:`sys.setprofile` for each "
"thread, before its :meth:`~Thread.run` method is called."
msgstr ""
"Attache une fonction de profilage pour tous les fils d'exécution démarrés "
"depuis le module :mod:`Threading`. La fonction *func* est passée à :func:"
"`sys.setprofile` pour chaque fil, avant que sa méthode :meth:`~Thread.run` "
"soit appelée."

#: library/threading.rst:135
msgid ""
"Return the thread stack size used when creating new threads.  The optional "
"*size* argument specifies the stack size to be used for subsequently created "
"threads, and must be 0 (use platform or configured default) or a positive "
"integer value of at least 32,768 (32 KiB). If *size* is not specified, 0 is "
"used.  If changing the thread stack size is unsupported, a :exc:"
"`RuntimeError` is raised.  If the specified stack size is invalid, a :exc:"
"`ValueError` is raised and the stack size is unmodified.  32 KiB is "
"currently the minimum supported stack size value to guarantee sufficient "
"stack space for the interpreter itself.  Note that some platforms may have "
"particular restrictions on values for the stack size, such as requiring a "
"minimum stack size > 32 KiB or requiring allocation in multiples of the "
"system memory page size - platform documentation should be referred to for "
"more information (4 KiB pages are common; using multiples of 4096 for the "
"stack size is the suggested approach in the absence of more specific "
"information)."
msgstr ""
"Renvoie la taille de la pile d'exécution utilisée lors de la création de "
"nouveaux fils d'exécution. L'argument optionnel *size* spécifie la taille de "
"pile à utiliser pour les fils créés ultérieurement, et doit être 0 (pour "
"utiliser la taille de la plate-forme ou la valeur configurée par défaut) ou "
"un entier positif supérieur ou égal à 32 768 (32 Kio). Si *size* n'est pas "
"spécifié, 0 est utilisé. Si la modification de la taille de la pile de fils "
"n'est pas prise en charge, une :exc:`RuntimeError` est levée. Si la taille "
"de pile spécifiée n'est pas valide, une :exc:`ValueError` est levée et la "
"taille de pile n'est pas modifiée. 32 Kio est actuellement la valeur "
"minimale de taille de pile prise en charge pour garantir un espace de pile "
"suffisant pour l'interpréteur lui-même. Notez que certaines plates-formes "
"peuvent avoir des restrictions particulières sur les valeurs de taille de la "
"pile, telles que l'exigence d'une taille de pile minimale > 32 Kio ou d'une "
"allocation en multiples de la taille de page de la mémoire du système – la "
"documentation de la plate-forme devrait être consultée pour plus "
"d'informations (4 Kio sont courantes ; en l'absence de renseignements plus "
"spécifiques, l'approche proposée est l'utilisation de multiples de 4 096 "
"pour la taille de la pile)."

#: library/threading.rst:150
msgid ""
":ref:`Availability <availability>`: Windows, systems with POSIX threads."
msgstr ""
":ref:`Disponibilité <availability>` : Windows et systèmes gérant les fils "
"d'exécution POSIX."

#: library/threading.rst:153
msgid "This module also defines the following constant:"
msgstr "Ce module définit également la constante suivante :"

#: library/threading.rst:157
msgid ""
"The maximum value allowed for the *timeout* parameter of blocking functions "
"(:meth:`Lock.acquire`, :meth:`RLock.acquire`, :meth:`Condition.wait`, etc.). "
"Specifying a timeout greater than this value will raise an :exc:"
"`OverflowError`."
msgstr ""
"La valeur maximale autorisée pour le paramètre *timeout* des fonctions "
"bloquantes (:meth:`Lock.acquire`, :meth:`RLock.acquire`, :meth:`Condition."
"wait`, etc.). Spécifier un délai d'attente supérieur à cette valeur lève "
"une :exc:`OverflowError`."

#: library/threading.rst:165
msgid ""
"This module defines a number of classes, which are detailed in the sections "
"below."
msgstr ""
"Ce module définit un certain nombre de classes, qui sont détaillées dans les "
"sections ci-dessous."

#: library/threading.rst:168
msgid ""
"The design of this module is loosely based on Java's threading model. "
"However, where Java makes locks and condition variables basic behavior of "
"every object, they are separate objects in Python.  Python's :class:`Thread` "
"class supports a subset of the behavior of Java's Thread class; currently, "
"there are no priorities, no thread groups, and threads cannot be destroyed, "
"stopped, suspended, resumed, or interrupted.  The static methods of Java's "
"Thread class, when implemented, are mapped to module-level functions."
msgstr ""
"La conception de ce module est librement basée sur le modèle des fils "
"d'exécution de Java. Cependant, là où Java fait des verrous et des variables "
"de condition le comportement de base de chaque objet, ils sont des objets "
"séparés en Python. La classe Python :class:`Thread` prend en charge un sous-"
"ensemble du comportement de la classe *Thread* de Java ; actuellement, il "
"n'y a aucune priorité, aucun groupe de fils d'exécution, et les fils ne "
"peuvent être détruits, arrêtés, suspendus, repris ni interrompus. Les "
"méthodes statiques de la classe *Thread* de Java, lorsqu'elles sont "
"implémentées, correspondent à des fonctions au niveau du module."

#: library/threading.rst:176
msgid "All of the methods described below are executed atomically."
msgstr ""
"Toutes les méthodes décrites ci-dessous sont exécutées de manière atomique."

#: library/threading.rst:180
msgid "Thread-Local Data"
msgstr "Données locales au fil d'exécution"

#: library/threading.rst:182
msgid ""
"Thread-local data is data whose values are thread specific.  To manage "
"thread-local data, just create an instance of :class:`local` (or a subclass) "
"and store attributes on it::"
msgstr ""
"Les données locales au fil d'exécution (*thread-local data*) sont des "
"données dont les valeurs sont propres à chaque fil. Pour gérer les données "
"locales au fil, il suffit de créer une instance de :class:`local` (ou une "
"sous-classe) et d'y stocker des données ::"

#: library/threading.rst:189
msgid "The instance's values will be different for separate threads."
msgstr ""
"Les valeurs dans l'instance sont différentes pour des *threads* différents."

#: library/threading.rst:194
msgid "A class that represents thread-local data."
msgstr "Classe qui représente les données locales au fil d'exécution."

#: library/threading.rst:196
msgid ""
"For more details and extensive examples, see the documentation string of "
"the :mod:`_threading_local` module."
msgstr ""
"Pour plus de détails et de nombreux exemples, voir la chaîne de "
"documentation du module :mod:`_threading_local`."

#: library/threading.rst:203
msgid "Thread Objects"
msgstr "Objets *Threads*"

#: library/threading.rst:205
msgid ""
"The :class:`Thread` class represents an activity that is run in a separate "
"thread of control.  There are two ways to specify the activity: by passing a "
"callable object to the constructor, or by overriding the :meth:`~Thread.run` "
"method in a subclass.  No other methods (except for the constructor) should "
"be overridden in a subclass.  In other words, *only*  override the :meth:"
"`~Thread.__init__` and :meth:`~Thread.run` methods of this class."
msgstr ""
"La classe fil d'exécution :class:`Thread` représente une activité qui est "
"exécutée dans un fil d'exécution séparé. Il y a deux façons de spécifier "
"l'activité : en passant un objet appelable au constructeur, ou en ré-"
"implémentant la méthode :meth:`~Thread.run` dans une sous-classe. Aucune "
"autre méthode (à l'exception du constructeur) ne doit être remplacée dans "
"une sous-classe. En d'autres termes, réimplémentez *seulement* les méthodes :"
"meth:`~Thread.__init__` et :meth:`~Thread.run` de cette classe."

#: library/threading.rst:212
msgid ""
"Once a thread object is created, its activity must be started by calling the "
"thread's :meth:`~Thread.start` method.  This invokes the :meth:`~Thread.run` "
"method in a separate thread of control."
msgstr ""
"Une fois qu'un objet fil d'exécution est créé, son activité doit être lancée "
"en appelant la méthode :meth:`~Thread.start` du fil. Ceci invoque la "
"méthode :meth:`~Thread.run` dans un fil d'exécution séparé."

#: library/threading.rst:216
msgid ""
"Once the thread's activity is started, the thread is considered 'alive'. It "
"stops being alive when its :meth:`~Thread.run` method terminates -- either "
"normally, or by raising an unhandled exception.  The :meth:`~Thread."
"is_alive` method tests whether the thread is alive."
msgstr ""
"Une fois que l'activité du fil d'exécution est lancée, le fil est considéré "
"comme « vivant ». Il cesse d'être vivant lorsque sa méthode :meth:`~Thread."
"run` se termine – soit normalement, soit en levant une exception non gérée. "
"La méthode :meth:`~Thread.is_alive` teste si le fil est vivant."

#: library/threading.rst:221
msgid ""
"Other threads can call a thread's :meth:`~Thread.join` method.  This blocks "
"the calling thread until the thread whose :meth:`~Thread.join` method is "
"called is terminated."
msgstr ""
"D'autres fils d'exécution peuvent appeler la méthode :meth:`~Thread.join` "
"d'un fil. Ceci bloque le fil appelant jusqu'à ce que le fil dont la méthode :"
"meth:`~Thread.join` est appelée soit terminé."

#: library/threading.rst:225
msgid ""
"A thread has a name.  The name can be passed to the constructor, and read or "
"changed through the :attr:`~Thread.name` attribute."
msgstr ""
"Un fil d'exécution a un nom. Le nom peut être passé au constructeur, et lu "
"ou modifié via l'attribut :attr:`~Thread.name`."

#: library/threading.rst:228
msgid ""
"If the :meth:`~Thread.run` method raises an exception, :func:`threading."
"excepthook` is called to handle it. By default, :func:`threading.excepthook` "
"ignores silently :exc:`SystemExit`."
msgstr ""
"Si la méthode :meth:`~Thread.run` lève une exception, :func:`threading."
"excepthook` est appelée pour s'en occuper. Par défaut, :func:`threading."
"excepthook` ignore silencieusement :exc:`SystemExit`."

#: library/threading.rst:232
msgid ""
"A thread can be flagged as a \"daemon thread\".  The significance of this "
"flag is that the entire Python program exits when only daemon threads are "
"left.  The initial value is inherited from the creating thread.  The flag "
"can be set through the :attr:`~Thread.daemon` property or the *daemon* "
"constructor argument."
msgstr ""
"Un fil d'exécution peut être marqué comme « fil démon ». Un programme Python "
"se termine quand il ne reste plus que des fils démons. La valeur initiale "
"est héritée du fil d'exécution qui l'a créé. Cette option peut être définie "
"par la propriété :attr:`~Thread.daemon` ou par l'argument *daemon* du "
"constructeur."

#: library/threading.rst:239
msgid ""
"Daemon threads are abruptly stopped at shutdown.  Their resources (such as "
"open files, database transactions, etc.) may not be released properly. If "
"you want your threads to stop gracefully, make them non-daemonic and use a "
"suitable signalling mechanism such as an :class:`Event`."
msgstr ""
"Les fils d'exécution démons sont brusquement terminés à l'arrêt du programme "
"Python. Leurs ressources (fichiers ouverts, transactions de base de données, "
"etc.) peuvent ne pas être libérées correctement. Si vous voulez que vos fils "
"s'arrêtent proprement, faites en sorte qu'ils ne soient pas démoniques et "
"utilisez un mécanisme de signalisation approprié tel qu'un objet évènement :"
"class:`Event`."

#: library/threading.rst:244
msgid ""
"There is a \"main thread\" object; this corresponds to the initial thread of "
"control in the Python program.  It is not a daemon thread."
msgstr ""
"Il y a un objet \"fil principal\", qui correspond au fil de contrôle initial "
"dans le programme Python. Ce n'est pas un fil démon."

#: library/threading.rst:247
msgid ""
"There is the possibility that \"dummy thread objects\" are created. These "
"are thread objects corresponding to \"alien threads\", which are threads of "
"control started outside the threading module, such as directly from C code.  "
"Dummy thread objects have limited functionality; they are always considered "
"alive and daemonic, and cannot be :meth:`~Thread.join`\\ ed.  They are never "
"deleted, since it is impossible to detect the termination of alien threads."
msgstr ""
"Il y a une possibilité que des objets fil d'exécution « fictifs » soient "
"créés. Ce sont des objets correspondant à des fils d'exécution "
"« étrangers », qui sont des fils de contrôle démarrés en dehors du module de "
"*threading*, par exemple directement depuis du code C. Les objets fils "
"d'exécution fictifs ont des fonctionnalités limitées ; ils sont toujours "
"considérés comme vivants et démoniques, et ne peuvent pas être attendus via :"
"meth:`~Thread.join`. Ils ne sont jamais supprimés, car il est impossible de "
"détecter la fin des fils d'exécution étrangers."

#: library/threading.rst:258
msgid ""
"This constructor should always be called with keyword arguments.  Arguments "
"are:"
msgstr ""
"Ce constructeur doit toujours être appelé avec des arguments nommés. Les "
"arguments sont :"

#: library/threading.rst:261
msgid ""
"*group* should be ``None``; reserved for future extension when a :class:"
"`ThreadGroup` class is implemented."
msgstr ""
"*group* doit être ``None`` ; cet argument est réservé pour une extension "
"future lorsqu'une classe :class:`ThreadGroup` sera implémentée."

#: library/threading.rst:264
msgid ""
"*target* is the callable object to be invoked by the :meth:`run` method. "
"Defaults to ``None``, meaning nothing is called."
msgstr ""
"*target* est l'objet appelable qui doit être invoqué par la méthode :meth:"
"`run`. La valeur par défaut est ``None``, ce qui signifie que rien n'est "
"appelé."

#: library/threading.rst:267
msgid ""
"*name* is the thread name.  By default, a unique name is constructed of the "
"form \"Thread-*N*\" where *N* is a small decimal number."
msgstr ""
"*name* est le nom du fil d'exécution. Par défaut, un nom unique est "
"construit de la forme « Thread–*N* » où *N* est un petit nombre décimal."

#: library/threading.rst:270
msgid ""
"*args* is the argument tuple for the target invocation.  Defaults to ``()``."
msgstr ""
"*args* est le *n*-uplet d'arguments pour l'invocation de l'objet appelable. "
"La valeur par défaut est ``()``."

#: library/threading.rst:272
msgid ""
"*kwargs* is a dictionary of keyword arguments for the target invocation. "
"Defaults to ``{}``."
msgstr ""
"*kwargs* est un dictionnaire d'arguments nommés pour l'invocation de l'objet "
"appelable. La valeur par défaut est ``{}``."

#: library/threading.rst:275
msgid ""
"If not ``None``, *daemon* explicitly sets whether the thread is daemonic. If "
"``None`` (the default), the daemonic property is inherited from the current "
"thread."
msgstr ""
"S'il ne vaut pas ``None``, *daemon* définit explicitement si le fil "
"d'exécution est démonique ou pas. S'il vaut ``None`` (par défaut), la valeur "
"est héritée du fil courant."

#: library/threading.rst:279
msgid ""
"If the subclass overrides the constructor, it must make sure to invoke the "
"base class constructor (``Thread.__init__()``) before doing anything else to "
"the thread."
msgstr ""
"Si la sous-classe réimplémente le constructeur, elle doit s'assurer "
"d'appeler le constructeur de la classe de base (``Thread.__init__()``) avant "
"de faire autre chose au fil d'exécution."

#: library/threading.rst:283
msgid "Added the *daemon* argument."
msgstr "Ajout de l'argument *daemon*."

#: library/threading.rst:288
msgid "Start the thread's activity."
msgstr "Lance l'activité du fil d'exécution."

#: library/threading.rst:290
msgid ""
"It must be called at most once per thread object.  It arranges for the "
"object's :meth:`~Thread.run` method to be invoked in a separate thread of "
"control."
msgstr ""
"Elle ne doit être appelée qu'une fois par objet de fil. Elle fait en sorte "
"que la méthode :meth:`~Thread.run` de l'objet soit invoquée dans un fil "
"d'exécution."

#: library/threading.rst:294
msgid ""
"This method will raise a :exc:`RuntimeError` if called more than once on the "
"same thread object."
msgstr ""
"Cette méthode lève une :exc:`RuntimeError` si elle est appelée plus d'une "
"fois sur le même objet fil d'exécution."

#: library/threading.rst:299
msgid "Method representing the thread's activity."
msgstr "Méthode représentant l'activité du fil d'exécution."

#: library/threading.rst:301
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 positional and keyword arguments taken from "
"the *args* and *kwargs* arguments, respectively."
msgstr ""
"Vous pouvez remplacer cette méthode dans une sous-classe.  La méthode "
"standard :meth:`run` invoque l'objet appelable passé au constructeur de "
"l'objet en tant qu'argument *target*, le cas échéant, avec des arguments "
"positionnels et des arguments nommés tirés respectivement des arguments "
"*args* et *kwargs*."

#: library/threading.rst:308
msgid ""
"Wait until the thread terminates. This blocks the calling thread until the "
"thread whose :meth:`~Thread.join` method is called terminates -- either "
"normally or through an unhandled exception -- or until the optional timeout "
"occurs."
msgstr ""
"Attend que le fil d'exécution se termine. Ceci bloque le fil appelant "
"jusqu'à ce que le fil dont la méthode :meth:`~Thread.join` est appelée se "
"termine – soit normalement, soit par une exception non gérée – ou jusqu'à ce "
"que le délai optionnel *timeout* soit atteint."

#: library/threading.rst:313
msgid ""
"When the *timeout* argument is present and not ``None``, it should be a "
"floating point number specifying a timeout for the operation in seconds (or "
"fractions thereof). As :meth:`~Thread.join` always returns ``None``, you "
"must call :meth:`~Thread.is_alive` after :meth:`~Thread.join` to decide "
"whether a timeout happened -- if the thread is still alive, the :meth:"
"`~Thread.join` call timed out."
msgstr ""
"Lorsque l'argument *timeout* est présent et ne vaut pas ``None``, il doit "
"être un nombre en virgule flottante spécifiant un délai pour l'opération en "
"secondes (ou fractions de secondes). Comme :meth:`~Thread.join` renvoie "
"toujours ``None``, vous devez appeler :meth:`~Thread.is_alive` après :meth:"
"`~Thread.join` pour déterminer si le délai a expiré – si le fil d'exécution "
"est toujours vivant, c'est que l'appel à :meth:`~Thread.join` a expiré."

#: library/threading.rst:320
msgid ""
"When the *timeout* argument is not present or ``None``, the operation will "
"block until the thread terminates."
msgstr ""
"Lorsque l'argument *timeout* n'est pas présent ou vaut ``None``, l'opération "
"se bloque jusqu'à ce que le fil d'exécution se termine."

#: library/threading.rst:323
msgid "A thread can be :meth:`~Thread.join`\\ ed many times."
msgstr ""
"Un fil d'exécution peut être attendu via :meth:`~Thread.join` de nombreuses "
"fois."

#: library/threading.rst:325
msgid ""
":meth:`~Thread.join` raises a :exc:`RuntimeError` if an attempt is made to "
"join the current thread as that would cause a deadlock. It is also an error "
"to :meth:`~Thread.join` a thread before it has been started and attempts to "
"do so raise the same exception."
msgstr ""
":meth:`~Thread.join` lève une :exc:`RuntimeError` si une tentative est faite "
"pour attendre le fil d'exécution courant car cela conduirait à un "
"interblocage (*deadlock* en anglais). Attendre via :meth:`~Thread.join` un "
"fil d'exécution avant son lancement est aussi une erreur et, si vous tentez "
"de le faire, lève la même exception."

#: library/threading.rst:332
msgid ""
"A string used for identification purposes only. It has no semantics. "
"Multiple threads may be given the same name.  The initial name is set by the "
"constructor."
msgstr ""
"Une chaîne de caractères utilisée à des fins d'identification seulement. "
"Elle n'a pas de sémantique. Plusieurs fils d'exécution peuvent porter le "
"même nom.  Le nom initial est défini par le constructeur."

#: library/threading.rst:339
msgid ""
"Old getter/setter API for :attr:`~Thread.name`; use it directly as a "
"property instead."
msgstr ""
"Anciens accesseur et mutateur pour :attr:`~Thread.name` ; utilisez plutôt ce "
"dernier directement."

#: library/threading.rst:344
msgid ""
"The 'thread identifier' of this thread or ``None`` if the thread has not "
"been started.  This is a nonzero integer.  See the :func:`get_ident` "
"function.  Thread identifiers may be recycled when a thread exits and "
"another thread is created.  The identifier is available even after the "
"thread has exited."
msgstr ""
"« L'identificateur de fil d'exécution » de ce fil ou ``None`` si le fil n'a "
"pas été lancé. C'est un entier non nul. Voyez également la fonction :func:"
"`get_ident`. Les identificateurs de fils peuvent être recyclés lorsqu'un fil "
"se termine et qu'un autre fil est créé. L'identifiant est disponible même "
"après que le fil ait terminé."

#: library/threading.rst:352
msgid ""
"The native integral thread ID of this thread. This is a non-negative "
"integer, or ``None`` if the thread has not been started. See the :func:"
"`get_native_id` function. This represents the Thread ID (``TID``) as "
"assigned to the thread by the OS (kernel).  Its value may be used to "
"uniquely identify this particular thread system-wide (until the thread "
"terminates, after which the value may be recycled by the OS)."
msgstr ""
"Le *Thread ID* de ce thread. C'est un nombre entier non-négatif, ou ``None`` "
"si le fil n'a pas encore démarré. Voir la fonction :func:`get_native_id`. "
"C'est la représentation de l'identifiant de *thread* (``TID``) tel "
"qu'assigné au fil d'exécution par le système d'exploitation. Cette valeur "
"peut être utilisée pour identifier de manière unique ce fil d'exécution dans "
"tout le système (jusqu'à la fin de l'exécution de ce fil, après quoi le "
"système d'exploitation peut recycler la valeur)."

#: library/threading.rst:362
msgid ""
"Similar to Process IDs, Thread IDs are only valid (guaranteed unique system-"
"wide) from the time the thread is created until the thread has been "
"terminated."
msgstr ""
"Tout comme pour les *Process IDs*, les *Thread IDs* ne sont valides "
"(garantis uniques sur le système) uniquement du démarrage du fil à sa fin."

#: library/threading.rst:367
msgid ""
":ref:`Availability <availability>`: Requires :func:`get_native_id` function."
msgstr ""
":ref:`Disponibilité <availability>` : nécessite la fonction :func:"
"`get_native_id`."

#: library/threading.rst:372
msgid "Return whether the thread is alive."
msgstr "Renvoie si le fil d'exécution est vivant ou pas."

#: library/threading.rst:374
msgid ""
"This method returns ``True`` just before the :meth:`~Thread.run` method "
"starts until just after the :meth:`~Thread.run` method terminates.  The "
"module function :func:`.enumerate` returns a list of all alive threads."
msgstr ""
"Cette méthode renvoie ``True`` depuis juste avant le démarrage de la "
"méthode :meth:`~Thread.run` et jusqu'à juste après la terminaison de la "
"méthode :meth:`~Thread.run`. La fonction :func:`.enumerate` du module "
"renvoie une liste de tous les fils d'exécution vivants."

#: library/threading.rst:380
msgid ""
"A boolean value indicating whether this thread is a daemon thread (True) or "
"not (False).  This must be set before :meth:`~Thread.start` is called, "
"otherwise :exc:`RuntimeError` is raised.  Its initial value is inherited "
"from the creating thread; the main thread is not a daemon thread and "
"therefore all threads created in the main thread default to :attr:`~Thread."
"daemon` = ``False``."
msgstr ""
"Booléen indiquant si ce fil  d'exécution est un fil démon (``True``) ou non "
"(``False``).  Celui-ci doit être défini avant que :meth:`~Thread.start` ne "
"soit appelé, sinon :exc:`RuntimeError` est levée.  Sa valeur initiale est "
"héritée du fil d'exécution créateur ; le fil principal n'est pas un fil "
"démon et donc tous les fils créés dans ce fil principal ont par défaut la "
"valeur :attr:`~Thread.daemon` = ``False``."

#: library/threading.rst:387
msgid ""
"The entire Python program exits when no alive non-daemon threads are left."
msgstr ""
"Le programme Python se termine lorsqu'il ne reste plus de fils d'exécution "
"non-démons vivants."

#: library/threading.rst:392
msgid ""
"Old getter/setter API for :attr:`~Thread.daemon`; use it directly as a "
"property instead."
msgstr ""
"Anciens accesseur et mutateur pour :attr:`~Thread.daemon` ; utilisez plutôt "
"ce dernier directement."

#: library/threading.rst:398
#, fuzzy
msgid ""
"In CPython, due to the :term:`Global Interpreter Lock <global interpreter "
"lock>`, only one thread can execute Python code at once (even though certain "
"performance-oriented libraries might overcome this limitation). If you want "
"your application to make better use of the computational resources of multi-"
"core machines, you are advised to use :mod:`multiprocessing` or :class:"
"`concurrent.futures.ProcessPoolExecutor`. However, threading is still an "
"appropriate model if you want to run multiple I/O-bound tasks simultaneously."
msgstr ""
"En CPython, en raison du verrou global de l'interpréteur (:term:`Global "
"Interpreter Lock`), un seul fil d'exécution peut exécuter du code Python à "
"la fois (même si certaines bibliothèques orientées performance peuvent "
"surmonter cette limitation). Si vous voulez que votre application fasse un "
"meilleur usage des ressources de calcul des machines multi-cœurs, nous vous "
"conseillons d'utiliser :mod:`multiprocessing` ou :class:`concurrent.futures."
"ProcessPoolExecutor`. Néanmoins, les fils d'exécutions multiples restent un "
"modèle approprié si vous souhaitez exécuter simultanément plusieurs tâches "
"limitées par les performances des entrées-sorties."

#: library/threading.rst:412
msgid "Lock Objects"
msgstr "Verrous"

#: library/threading.rst:414
msgid ""
"A primitive lock is a synchronization primitive that is not owned by a "
"particular thread when locked.  In Python, it is currently the lowest level "
"synchronization primitive available, implemented directly by the :mod:"
"`_thread` extension module."
msgstr ""
"Un verrou primitif n'appartient pas à un fil d'exécution lorsqu'il est "
"verrouillé. En Python, c'est actuellement la méthode de synchronisation la "
"plus bas-niveau qui soit disponible, implémentée directement par le module "
"d'extension :mod:`_thread`."

#: library/threading.rst:419
msgid ""
"A primitive lock is in one of two states, \"locked\" or \"unlocked\". It is "
"created in the unlocked state.  It has two basic methods, :meth:`~Lock."
"acquire` and :meth:`~Lock.release`.  When the state is unlocked, :meth:"
"`~Lock.acquire` changes the state to locked and returns immediately.  When "
"the state is locked, :meth:`~Lock.acquire` blocks until a call to :meth:"
"`~Lock.release` in another thread changes it to unlocked, then the :meth:"
"`~Lock.acquire` call resets it to locked and returns.  The :meth:`~Lock."
"release` method should only be called in the locked state; it changes the "
"state to unlocked and returns immediately. If an attempt is made to release "
"an unlocked lock, a :exc:`RuntimeError` will be raised."
msgstr ""
"Un verrou primitif est soit « verrouillé » soit « déverrouillé ». Il est "
"créé dans un état déverrouillé. Il a deux méthodes, :meth:`~Lock.acquire` "
"et :meth:`~Lock.release`. Lorsque l'état est déverrouillé, :meth:`~Lock."
"acquire` verrouille et se termine immédiatement. Lorsque l'état est "
"verrouillé, :meth:`~Lock.acquire` bloque jusqu'à ce qu'un appel à :meth:"
"`~Lock.release` provenant d'un autre fil d'exécution le déverrouille. À ce "
"moment :meth:`~Lock.acquire` le verrouille à nouveau et rend la main. La "
"méthode :meth:`~Lock.release` ne doit être appelée que si le verrou est "
"verrouillé, elle le déverrouille alors et se termine immédiatement. "
"Déverrouiller un verrou qui n'est pas verrouillé provoque une :exc:"
"`RuntimeError`."

#: library/threading.rst:430
msgid "Locks also support the :ref:`context management protocol <with-locks>`."
msgstr ""

#: library/threading.rst:432
msgid ""
"When more than one thread is blocked in :meth:`~Lock.acquire` waiting for "
"the state to turn to unlocked, only one thread proceeds when a :meth:`~Lock."
"release` call resets the state to unlocked; which one of the waiting threads "
"proceeds is not defined, and may vary across implementations."
msgstr ""

#: library/threading.rst:437
msgid "All methods are executed atomically."
msgstr ""

#: library/threading.rst:442
msgid ""
"The class implementing primitive lock objects.  Once a thread has acquired a "
"lock, subsequent attempts to acquire it block, until it is released; any "
"thread may release it."
msgstr ""

#: library/threading.rst:446
msgid ""
"Note that ``Lock`` is actually a factory function which returns an instance "
"of the most efficient version of the concrete Lock class that is supported "
"by the platform."
msgstr ""

#: library/threading.rst:533
msgid "Acquire a lock, blocking or non-blocking."
msgstr "Acquiert un verrou, bloquant ou non bloquant."

#: library/threading.rst:455
msgid ""
"When invoked with the *blocking* argument set to ``True`` (the default), "
"block until the lock is unlocked, then set it to locked and return ``True``."
msgstr ""

#: library/threading.rst:458
msgid ""
"When invoked with the *blocking* argument set to ``False``, do not block. If "
"a call with *blocking* set to ``True`` would block, return ``False`` "
"immediately; otherwise, set the lock to locked and return ``True``."
msgstr ""

#: library/threading.rst:462
msgid ""
"When invoked with the floating-point *timeout* argument set to a positive "
"value, block for at most the number of seconds specified by *timeout* and as "
"long as the lock cannot be acquired.  A *timeout* argument of ``-1`` "
"specifies an unbounded wait.  It is forbidden to specify a *timeout* when "
"*blocking* is false."
msgstr ""

#: library/threading.rst:468
msgid ""
"The return value is ``True`` if the lock is acquired successfully, ``False`` "
"if not (for example if the *timeout* expired)."
msgstr ""

#: library/threading.rst:555 library/threading.rst:800
msgid "The *timeout* parameter is new."
msgstr "Le paramètre *timeout* est nouveau."

#: library/threading.rst:474
msgid ""
"Lock acquisition can now be interrupted by signals on POSIX if the "
"underlying threading implementation supports it."
msgstr ""

#: library/threading.rst:481
msgid ""
"Release a lock.  This can be called from any thread, not only the thread "
"which has acquired the lock."
msgstr ""

#: library/threading.rst:484
msgid ""
"When the lock is locked, reset it to unlocked, and return.  If any other "
"threads are blocked waiting for the lock to become unlocked, allow exactly "
"one of them to proceed."
msgstr ""

#: library/threading.rst:488
msgid "When invoked on an unlocked lock, a :exc:`RuntimeError` is raised."
msgstr ""

#: library/threading.rst:571
msgid "There is no return value."
msgstr "Il n'y a pas de valeur de retour."

#: library/threading.rst:494
msgid "Return true if the lock is acquired."
msgstr "Renvoie ``True`` si le verrou est acquis."

#: library/threading.rst:501
msgid "RLock Objects"
msgstr ""

#: library/threading.rst:503
msgid ""
"A reentrant lock is a synchronization primitive that may be acquired "
"multiple times by the same thread.  Internally, it uses the concepts of "
"\"owning thread\" and \"recursion level\" in addition to the locked/unlocked "
"state used by primitive locks.  In the locked state, some thread owns the "
"lock; in the unlocked state, no thread owns it."
msgstr ""

#: library/threading.rst:509
msgid ""
"To lock the lock, a thread calls its :meth:`~RLock.acquire` method; this "
"returns once the thread owns the lock.  To unlock the lock, a thread calls "
"its :meth:`~Lock.release` method. :meth:`~Lock.acquire`/:meth:`~Lock."
"release` call pairs may be nested; only the final :meth:`~Lock.release` "
"(the :meth:`~Lock.release` of the outermost pair) resets the lock to "
"unlocked and allows another thread blocked in :meth:`~Lock.acquire` to "
"proceed."
msgstr ""

#: library/threading.rst:516
msgid ""
"Reentrant locks also support the :ref:`context management protocol <with-"
"locks>`."
msgstr ""

#: library/threading.rst:521
msgid ""
"This class implements reentrant lock objects.  A reentrant lock must be "
"released by the thread that acquired it.  Once a thread has acquired a "
"reentrant lock, the same thread may acquire it again without blocking; the "
"thread must release it once for each time it has acquired it."
msgstr ""

#: library/threading.rst:526
msgid ""
"Note that ``RLock`` is actually a factory function which returns an instance "
"of the most efficient version of the concrete RLock class that is supported "
"by the platform."
msgstr ""

#: library/threading.rst:535
msgid ""
"When invoked without arguments: if this thread already owns the lock, "
"increment the recursion level by one, and return immediately.  Otherwise, if "
"another thread owns the lock, block until the lock is unlocked.  Once the "
"lock is unlocked (not owned by any thread), then grab ownership, set the "
"recursion level to one, and return.  If more than one thread is blocked "
"waiting until the lock is unlocked, only one at a time will be able to grab "
"ownership of the lock. There is no return value in this case."
msgstr ""

#: library/threading.rst:543
msgid ""
"When invoked with the *blocking* argument set to true, do the same thing as "
"when called without arguments, and return ``True``."
msgstr ""

#: library/threading.rst:546
msgid ""
"When invoked with the *blocking* argument set to false, do not block.  If a "
"call without an argument would block, return ``False`` immediately; "
"otherwise, do the same thing as when called without arguments, and return "
"``True``."
msgstr ""

#: library/threading.rst:550
msgid ""
"When invoked with the floating-point *timeout* argument set to a positive "
"value, block for at most the number of seconds specified by *timeout* and as "
"long as the lock cannot be acquired.  Return ``True`` if the lock has been "
"acquired, false if the timeout has elapsed."
msgstr ""

#: library/threading.rst:561
msgid ""
"Release a lock, decrementing the recursion level.  If after the decrement it "
"is zero, reset the lock to unlocked (not owned by any thread), and if any "
"other 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 thread."
msgstr ""

#: library/threading.rst:567
msgid ""
"Only call this method when the calling thread owns the lock. A :exc:"
"`RuntimeError` is raised if this method is called when the lock is unlocked."
msgstr ""

#: library/threading.rst:577
msgid "Condition Objects"
msgstr ""

#: library/threading.rst:579
msgid ""
"A condition variable is always associated with some kind of lock; this can "
"be passed in or one will be created by default.  Passing one in is useful "
"when several condition variables must share the same lock.  The lock is part "
"of the condition object: you don't have to track it separately."
msgstr ""

#: library/threading.rst:584
msgid ""
"A condition variable obeys the :ref:`context management protocol <with-"
"locks>`: using the ``with`` statement acquires the associated lock for the "
"duration of the enclosed block.  The :meth:`~Condition.acquire` and :meth:"
"`~Condition.release` methods also call the corresponding methods of the "
"associated lock."
msgstr ""

#: library/threading.rst:590
msgid ""
"Other methods must be called with the associated lock held.  The :meth:"
"`~Condition.wait` method releases the lock, and then blocks until another "
"thread awakens it by calling :meth:`~Condition.notify` or :meth:`~Condition."
"notify_all`.  Once awakened, :meth:`~Condition.wait` re-acquires the lock "
"and returns.  It is also possible to specify a timeout."
msgstr ""

#: library/threading.rst:596
msgid ""
"The :meth:`~Condition.notify` method wakes up one of the threads waiting for "
"the condition variable, if any are waiting.  The :meth:`~Condition."
"notify_all` method wakes up all threads waiting for the condition variable."
msgstr ""

#: library/threading.rst:600
msgid ""
"Note: the :meth:`~Condition.notify` and :meth:`~Condition.notify_all` "
"methods don't release the lock; this means that the thread or threads "
"awakened will not return from their :meth:`~Condition.wait` call "
"immediately, but only when the thread that called :meth:`~Condition.notify` "
"or :meth:`~Condition.notify_all` finally relinquishes ownership of the lock."
msgstr ""

#: library/threading.rst:606
msgid ""
"The typical programming style using condition variables uses the lock to "
"synchronize access to some shared state; threads that are interested in a "
"particular change of state call :meth:`~Condition.wait` repeatedly until "
"they see the desired state, while threads that modify the state call :meth:"
"`~Condition.notify` or :meth:`~Condition.notify_all` when they change the "
"state in such a way that it could possibly be a desired state for one of the "
"waiters.  For example, the following code is a generic producer-consumer "
"situation with unlimited buffer capacity::"
msgstr ""

#: library/threading.rst:626
msgid ""
"The ``while`` loop checking for the application's condition is necessary "
"because :meth:`~Condition.wait` can return after an arbitrary long time, and "
"the condition which prompted the :meth:`~Condition.notify` call may no "
"longer hold true.  This is inherent to multi-threaded programming.  The :"
"meth:`~Condition.wait_for` method can be used to automate the condition "
"checking, and eases the computation of timeouts::"
msgstr ""

#: library/threading.rst:638
msgid ""
"To choose between :meth:`~Condition.notify` and :meth:`~Condition."
"notify_all`, consider whether one state change can be interesting for only "
"one or several waiting threads.  E.g. in a typical producer-consumer "
"situation, adding one item to the buffer only needs to wake up one consumer "
"thread."
msgstr ""

#: library/threading.rst:646
msgid ""
"This class implements condition variable objects.  A condition variable "
"allows one or more threads to wait until they are notified by another thread."
msgstr ""

#: library/threading.rst:649
msgid ""
"If the *lock* argument is given and not ``None``, it must be a :class:`Lock` "
"or :class:`RLock` object, and it is used as the underlying lock.  Otherwise, "
"a new :class:`RLock` object is created and used as the underlying lock."
msgstr ""

#: library/threading.rst:775 library/threading.rst:873
#: library/threading.rst:942
msgid "changed from a factory function to a class."
msgstr ""

#: library/threading.rst:658
msgid ""
"Acquire the underlying lock. This method calls the corresponding method on "
"the underlying lock; the return value is whatever that method returns."
msgstr ""

#: library/threading.rst:663
msgid ""
"Release the underlying lock. This method calls the corresponding method on "
"the underlying lock; there is no return value."
msgstr ""

#: library/threading.rst:668
msgid ""
"Wait until notified or until a timeout occurs. If the calling thread has not "
"acquired the lock when this method is called, a :exc:`RuntimeError` is "
"raised."
msgstr ""

#: library/threading.rst:672
msgid ""
"This method releases the underlying lock, and then blocks until it is "
"awakened by a :meth:`notify` or :meth:`notify_all` call for the same "
"condition variable in another thread, or until the optional timeout occurs.  "
"Once awakened or timed out, it re-acquires the lock and returns."
msgstr ""

#: library/threading.rst:677
msgid ""
"When the *timeout* argument is present and not ``None``, it should be a "
"floating point number specifying a timeout for the operation in seconds (or "
"fractions thereof)."
msgstr ""

#: library/threading.rst:681
msgid ""
"When the underlying lock is an :class:`RLock`, it is not released using its :"
"meth:`release` method, since this may not actually unlock the lock when it "
"was acquired multiple times recursively.  Instead, an internal interface of "
"the :class:`RLock` class is used, which really unlocks it even when it has "
"been recursively acquired several times. Another internal interface is then "
"used to restore the recursion level when the lock is reacquired."
msgstr ""

#: library/threading.rst:689
msgid ""
"The return value is ``True`` unless a given *timeout* expired, in which case "
"it is ``False``."
msgstr ""

#: library/threading.rst:907
msgid "Previously, the method always returned ``None``."
msgstr ""

#: library/threading.rst:697
msgid ""
"Wait until a condition evaluates to true.  *predicate* should be a callable "
"which result will be interpreted as a boolean value. A *timeout* may be "
"provided giving the maximum time to wait."
msgstr ""

#: library/threading.rst:701
msgid ""
"This utility method may call :meth:`wait` repeatedly until the predicate is "
"satisfied, or until a timeout occurs. The return value is the last return "
"value of the predicate and will evaluate to ``False`` if the method timed "
"out."
msgstr ""

#: library/threading.rst:706
msgid ""
"Ignoring the timeout feature, calling this method is roughly equivalent to "
"writing::"
msgstr ""

#: library/threading.rst:712
msgid ""
"Therefore, the same rules apply as with :meth:`wait`: The lock must be held "
"when called and is re-acquired on return.  The predicate is evaluated with "
"the lock held."
msgstr ""

#: library/threading.rst:720
msgid ""
"By default, wake up one thread waiting on this condition, if any.  If the "
"calling thread has not acquired the lock when this method is called, a :exc:"
"`RuntimeError` is raised."
msgstr ""

#: library/threading.rst:724
msgid ""
"This method wakes up at most *n* of the threads waiting for the condition "
"variable; it is a no-op if no threads are waiting."
msgstr ""

#: library/threading.rst:727
msgid ""
"The current implementation wakes up exactly *n* threads, if at least *n* "
"threads are waiting.  However, it's not safe to rely on this behavior. A "
"future, optimized implementation may occasionally wake up more than *n* "
"threads."
msgstr ""

#: library/threading.rst:732
msgid ""
"Note: an awakened thread does not actually return from its :meth:`wait` call "
"until it can reacquire the lock.  Since :meth:`notify` does not release the "
"lock, its caller should."
msgstr ""

#: library/threading.rst:738
msgid ""
"Wake up all threads waiting on this condition.  This method acts like :meth:"
"`notify`, but wakes up all waiting threads instead of one. If the calling "
"thread has not acquired the lock when this method is called, a :exc:"
"`RuntimeError` is raised."
msgstr ""

#: library/threading.rst:747
msgid "Semaphore Objects"
msgstr ""

#: library/threading.rst:749
msgid ""
"This is one of the oldest synchronization primitives in the history of "
"computer science, invented by the early Dutch computer scientist Edsger W. "
"Dijkstra (he used the names ``P()`` and ``V()`` instead of :meth:`~Semaphore."
"acquire` and :meth:`~Semaphore.release`)."
msgstr ""

#: library/threading.rst:754
msgid ""
"A semaphore manages an internal counter which is decremented by each :meth:"
"`~Semaphore.acquire` call and incremented by each :meth:`~Semaphore.release` "
"call.  The counter can never go below zero; when :meth:`~Semaphore.acquire` "
"finds that it is zero, it blocks, waiting until some other thread calls :"
"meth:`~Semaphore.release`."
msgstr ""

#: library/threading.rst:760
msgid ""
"Semaphores also support the :ref:`context management protocol <with-locks>`."
msgstr ""

#: library/threading.rst:765
msgid ""
"This class implements semaphore objects.  A semaphore manages an atomic "
"counter representing the number of :meth:`release` calls minus the number "
"of :meth:`acquire` calls, plus an initial value.  The :meth:`acquire` method "
"blocks if necessary until it can return without making the counter negative. "
"If not given, *value* defaults to 1."
msgstr ""

#: library/threading.rst:771
msgid ""
"The optional argument gives the initial *value* for the internal counter; it "
"defaults to ``1``. If the *value* given is less than 0, :exc:`ValueError` is "
"raised."
msgstr ""

#: library/threading.rst:780
msgid "Acquire a semaphore."
msgstr ""

#: library/threading.rst:782
msgid "When invoked without arguments:"
msgstr ""

#: library/threading.rst:784
msgid ""
"If the internal counter is larger than zero on entry, decrement it by one "
"and return ``True`` immediately."
msgstr ""

#: library/threading.rst:786
msgid ""
"If the internal counter is zero on entry, block until awoken by a call to :"
"meth:`~Semaphore.release`.  Once awoken (and the counter is greater than 0), "
"decrement the counter by 1 and return ``True``.  Exactly one thread will be "
"awoken by each call to :meth:`~Semaphore.release`.  The order in which "
"threads are awoken should not be relied on."
msgstr ""

#: library/threading.rst:792
msgid ""
"When invoked with *blocking* set to false, do not block.  If a call without "
"an argument would block, return ``False`` immediately; otherwise, do the "
"same thing as when called without arguments, and return ``True``."
msgstr ""

#: library/threading.rst:796
msgid ""
"When invoked with a *timeout* other than ``None``, it will block for at most "
"*timeout* seconds.  If acquire does not complete successfully in that "
"interval, return ``False``.  Return ``True`` otherwise."
msgstr ""

#: library/threading.rst:805
msgid ""
"Release a semaphore, incrementing the internal counter by *n*.  When it was "
"zero on entry and other threads are waiting for it to become larger than "
"zero again, wake up *n* of those threads."
msgstr ""

#: library/threading.rst:809
msgid "Added the *n* parameter to release multiple waiting threads at once."
msgstr ""

#: library/threading.rst:815
msgid ""
"Class implementing bounded semaphore objects.  A bounded semaphore checks to "
"make sure its current value doesn't exceed its initial value.  If it does, :"
"exc:`ValueError` is raised. In most situations semaphores are used to guard "
"resources with limited capacity.  If the semaphore is released too many "
"times it's a sign of a bug.  If not given, *value* defaults to 1."
msgstr ""

#: library/threading.rst:828
msgid ":class:`Semaphore` Example"
msgstr ""

#: library/threading.rst:830
msgid ""
"Semaphores are often used to guard resources with limited capacity, for "
"example, a database server.  In any situation where the size of the resource "
"is fixed, you should use a bounded semaphore.  Before spawning any worker "
"threads, your main thread would initialize the semaphore::"
msgstr ""

#: library/threading.rst:839
msgid ""
"Once spawned, worker threads call the semaphore's acquire and release "
"methods when they need to connect to the server::"
msgstr ""

#: library/threading.rst:849
msgid ""
"The use of a bounded semaphore reduces the chance that a programming error "
"which causes the semaphore to be released more than it's acquired will go "
"undetected."
msgstr ""

#: library/threading.rst:856
msgid "Event Objects"
msgstr ""

#: library/threading.rst:858
msgid ""
"This is one of the simplest mechanisms for communication between threads: "
"one thread signals an event and other threads wait for it."
msgstr ""

#: library/threading.rst:861
msgid ""
"An event object manages an internal flag that can be set to true with the :"
"meth:`~Event.set` method and reset to false with the :meth:`~Event.clear` "
"method.  The :meth:`~Event.wait` method blocks until the flag is true."
msgstr ""

#: library/threading.rst:868
msgid ""
"Class implementing event objects.  An event manages a flag that can be set "
"to true with the :meth:`~Event.set` method and reset to false with the :meth:"
"`clear` method.  The :meth:`wait` method blocks until the flag is true. The "
"flag is initially false."
msgstr ""

#: library/threading.rst:878
msgid "Return ``True`` if and only if the internal flag is true."
msgstr ""

#: library/threading.rst:882
msgid ""
"Set the internal flag to true. All threads waiting for it to become true are "
"awakened. Threads that call :meth:`wait` once the flag is true will not "
"block at all."
msgstr ""

#: library/threading.rst:888
msgid ""
"Reset the internal flag to false. Subsequently, threads calling :meth:`wait` "
"will block until :meth:`.set` is called to set the internal flag to true "
"again."
msgstr ""

#: library/threading.rst:894
msgid ""
"Block until the internal flag is true.  If the internal flag is true on "
"entry, return immediately.  Otherwise, block until another thread calls :"
"meth:`.set` to set the flag to true, or until the optional timeout occurs."
msgstr ""

#: library/threading.rst:898
msgid ""
"When the timeout argument is present and not ``None``, it should be a "
"floating point number specifying a timeout for the operation in seconds (or "
"fractions thereof)."
msgstr ""

#: library/threading.rst:902
msgid ""
"This method returns ``True`` if and only if the internal flag has been set "
"to true, either before the wait call or after the wait starts, so it will "
"always return ``True`` except if a timeout is given and the operation times "
"out."
msgstr ""

#: library/threading.rst:914
msgid "Timer Objects"
msgstr ""

#: library/threading.rst:916
msgid ""
"This class represents an action that should be run only after a certain "
"amount of time has passed --- a timer.  :class:`Timer` is a subclass of :"
"class:`Thread` and as such also functions as an example of creating custom "
"threads."
msgstr ""

#: library/threading.rst:920
msgid ""
"Timers are started, as with threads, by calling their :meth:`~Timer.start` "
"method.  The timer can be stopped (before its action has begun) by calling "
"the :meth:`~Timer.cancel` method.  The interval the timer will wait before "
"executing its action may not be exactly the same as the interval specified "
"by the user."
msgstr ""

#: library/threading.rst:926
msgid "For example::"
msgstr "Par exemple ::"

#: library/threading.rst:937
msgid ""
"Create a timer that will run *function* with arguments *args* and  keyword "
"arguments *kwargs*, after *interval* seconds have passed. If *args* is "
"``None`` (the default) then an empty list will be used. If *kwargs* is "
"``None`` (the default) then an empty dict will be used."
msgstr ""

#: library/threading.rst:947
msgid ""
"Stop the timer, and cancel the execution of the timer's action.  This will "
"only work if the timer is still in its waiting stage."
msgstr ""

#: library/threading.rst:952
msgid "Barrier Objects"
msgstr ""

#: library/threading.rst:956
msgid ""
"This class provides a simple synchronization primitive for use by a fixed "
"number of threads that need to wait for each other.  Each of the threads "
"tries to pass the barrier by calling the :meth:`~Barrier.wait` method and "
"will block until all of the threads have made their :meth:`~Barrier.wait` "
"calls. At this point, the threads are released simultaneously."
msgstr ""

#: library/threading.rst:962
msgid ""
"The barrier can be reused any number of times for the same number of threads."
msgstr ""

#: library/threading.rst:964
msgid ""
"As an example, here is a simple way to synchronize a client and server "
"thread::"
msgstr ""

#: library/threading.rst:984
msgid ""
"Create a barrier object for *parties* number of threads.  An *action*, when "
"provided, is a callable to be called by one of the threads when they are "
"released.  *timeout* is the default timeout value if none is specified for "
"the :meth:`wait` method."
msgstr ""

#: library/threading.rst:991
msgid ""
"Pass the barrier.  When all the threads party to the barrier have called "
"this function, they are all released simultaneously.  If a *timeout* is "
"provided, it is used in preference to any that was supplied to the class "
"constructor."
msgstr ""

#: library/threading.rst:996
msgid ""
"The return value is an integer in the range 0 to *parties* -- 1, different "
"for each thread.  This can be used to select a thread to do some special "
"housekeeping, e.g.::"
msgstr ""

#: library/threading.rst:1005
msgid ""
"If an *action* was provided to the constructor, one of the threads will have "
"called it prior to being released.  Should this call raise an error, the "
"barrier is put into the broken state."
msgstr ""

#: library/threading.rst:1009
msgid "If the call times out, the barrier is put into the broken state."
msgstr ""

#: library/threading.rst:1011
msgid ""
"This method may raise a :class:`BrokenBarrierError` exception if the barrier "
"is broken or reset while a thread is waiting."
msgstr ""

#: library/threading.rst:1016
msgid ""
"Return the barrier to the default, empty state.  Any threads waiting on it "
"will receive the :class:`BrokenBarrierError` exception."
msgstr ""

#: library/threading.rst:1019
msgid ""
"Note that using this function may require some external synchronization if "
"there are other threads whose state is unknown.  If a barrier is broken it "
"may be better to just leave it and create a new one."
msgstr ""

#: library/threading.rst:1025
msgid ""
"Put the barrier into a broken state.  This causes any active or future calls "
"to :meth:`wait` to fail with the :class:`BrokenBarrierError`.  Use this for "
"example if one of the threads needs to abort, to avoid deadlocking the "
"application."
msgstr ""

#: library/threading.rst:1030
msgid ""
"It may be preferable to simply create the barrier with a sensible *timeout* "
"value to automatically guard against one of the threads going awry."
msgstr ""

#: library/threading.rst:1036
msgid "The number of threads required to pass the barrier."
msgstr ""

#: library/threading.rst:1040
msgid "The number of threads currently waiting in the barrier."
msgstr ""

#: library/threading.rst:1044
msgid "A boolean that is ``True`` if the barrier is in the broken state."
msgstr ""

#: library/threading.rst:1049
msgid ""
"This exception, a subclass of :exc:`RuntimeError`, is raised when the :class:"
"`Barrier` object is reset or broken."
msgstr ""

#: library/threading.rst:1056
msgid ""
"Using locks, conditions, and semaphores in the :keyword:`!with` statement"
msgstr ""

#: library/threading.rst:1058
msgid ""
"All of the objects provided by this module that have :meth:`acquire` and :"
"meth:`release` methods can be used as context managers for a :keyword:`with` "
"statement.  The :meth:`acquire` method will be called when the block is "
"entered, and :meth:`release` will be called when the block is exited.  "
"Hence, the following snippet::"
msgstr ""

#: library/threading.rst:1067
msgid "is equivalent to::"
msgstr "est équivalente à ::"

#: library/threading.rst:1075
msgid ""
"Currently, :class:`Lock`, :class:`RLock`, :class:`Condition`, :class:"
"`Semaphore`, and :class:`BoundedSemaphore` objects may be used as :keyword:"
"`with` statement context managers."
msgstr ""