python-docs-fr/library/queue.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: 2023-04-14 13:19+0200\n"
"PO-Revision-Date: 2019-11-01 17:35+0100\n"
"Last-Translator: Lcaracol <lcaracol@riseup.net>\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.2.1\n"

#: library/queue.rst:2
msgid ":mod:`queue` --- A synchronized queue class"
msgstr ":mod:`queue` — File synchronisée"

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

#: library/queue.rst:11
msgid ""
"The :mod:`queue` module implements multi-producer, multi-consumer queues. It "
"is especially useful in threaded programming when information must be "
"exchanged safely between multiple threads.  The :class:`Queue` class in this "
"module implements all the required locking semantics."
msgstr ""
"Le module :mod:`queue` implémente des files multi-productrices et multi-"
"consommatrices. C'est particulièrement utile en programmation *multi-"
"thread*, lorsque les informations doivent être échangées sans risques entre "
"plusieurs *threads*. La classe :class:`Queue` de ce module implémente tout "
"le verrouillage nécessaire."

#: library/queue.rst:16
#, fuzzy
msgid ""
"The module implements three types of queue, which differ only in the order "
"in which the entries are retrieved.  In a :abbr:`FIFO (first-in, first-out)` "
"queue, the first tasks added are the first retrieved.  In a :abbr:`LIFO "
"(last-in, first-out)` queue, the most recently added entry is the first "
"retrieved (operating like a stack).  With a priority queue, the entries are "
"kept sorted (using the :mod:`heapq` module) and the lowest valued entry is "
"retrieved first."
msgstr ""
"Le module implémente trois types de files qui différent par l'ordre dans "
"lequel les éléments en sont extraits. Dans une file :abbr:`FIFO (first-in, "
"first-out)`, les premiers éléments ajoutés sont les premiers extraits. Dans "
"une file :abbr:`LIFO (last-in, first-out)`, le dernier élément ajouté est le "
"premier élément extrait (se comporte comme une pile). Avec une file de "
"priorité, les entrées restent triés (en utilisant le module :mod:`heapq`)  "
"et l'élément ayant la valeur la plus faible est extrait en premier."

#: library/queue.rst:24
msgid ""
"Internally, those three types of queues use locks to temporarily block "
"competing threads; however, they are not designed to handle reentrancy "
"within a thread."
msgstr ""
"En interne, ces trois types de files utilisent des verrous pour bloquer "
"temporairement des fils d'exécution concurrents. Cependant, ils n'ont pas "
"été conçus pour être réentrants au sein d'un fil d'exécution."

#: library/queue.rst:28
msgid ""
"In addition, the module implements a \"simple\" :abbr:`FIFO (first-in, first-"
"out)` queue type, :class:`SimpleQueue`, whose specific implementation "
"provides additional guarantees in exchange for the smaller functionality."
msgstr ""
"Le module implémente aussi une :abbr:`FIFO (first-in, first-out)` basique, :"
"class:`SimpleQueue`, dont l’implémentation spécialisée fournit plus de "
"garanties au détriment des fonctionnalités."

#: library/queue.rst:33
msgid "The :mod:`queue` module defines the following classes and exceptions:"
msgstr ""
"Le module :mod:`queue` définit les classes et les exceptions suivantes :"

#: library/queue.rst:37
msgid ""
"Constructor for a :abbr:`FIFO (first-in, first-out)` queue.  *maxsize* is an "
"integer that sets the upperbound limit on the number of items that can be "
"placed in the queue.  Insertion will block once this size has been reached, "
"until queue items are consumed.  If *maxsize* is less than or equal to zero, "
"the queue size is infinite."
msgstr ""
"Constructeur pour une file :abbr:`FIFO (first-in, first-out)`. *maxsize* est "
"un entier définissant le nombre maximal d'éléments pouvant être mis dans la "
"file. L'insertion sera bloquée lorsque cette borne supérieure sera atteinte, "
"jusqu'à ce que des éléments de la file soient consommés. Si *maxsize* est "
"inférieur ou égal à 0, la taille de la file sera infinie."

#: library/queue.rst:45
msgid ""
"Constructor for a :abbr:`LIFO (last-in, first-out)` queue.  *maxsize* is an "
"integer that sets the upperbound limit on the number of items that can be "
"placed in the queue.  Insertion will block once this size has been reached, "
"until queue items are consumed.  If *maxsize* is less than or equal to zero, "
"the queue size is infinite."
msgstr ""
"Constructeur pour une file :abbr:`LIFO (last-in, first-out)`. *maxsize* est "
"un entier définissant le nombre maximal d'éléments pouvant être mis dans la "
"file. L'insertion sera bloquée lorsque cette borne supérieure sera atteinte, "
"jusqu'à ce que des éléments de la file soient consommés. Si *maxsize* est "
"inférieur ou égal à 0, la taille de la file sera infinie."

#: library/queue.rst:54
msgid ""
"Constructor for a priority queue.  *maxsize* is an integer that sets the "
"upperbound limit on the number of items that can be placed in the queue.  "
"Insertion will block once this size has been reached, until queue items are "
"consumed.  If *maxsize* is less than or equal to zero, the queue size is "
"infinite."
msgstr ""
"Constructeur pour une file de priorité. *maxsize* est un entier définissant "
"le nombre maximal d'éléments pouvant être mis dans la file. L'insertion sera "
"bloquée lorsque cette borne supérieure sera atteinte, jusqu'à ce que des "
"éléments soient consommés. Si *maxsize* est inférieur ou égal à 0, la taille "
"de la file sera infinie."

#: library/queue.rst:59
#, fuzzy
msgid ""
"The lowest valued entries are retrieved first (the lowest valued entry is "
"the one that would be returned by ``min(entries)``).  A typical pattern for "
"entries is a tuple in the form: ``(priority_number, data)``."
msgstr ""
"Les éléments de valeurs les plus faibles sont extraits en premier (l'élément "
"de valeur la plus faible est celui renvoyé par ``sorted(list(entries))"
"[0]``). On utilise souvent des paires de la forme : ``(priority_number, "
"data)``."

#: library/queue.rst:63
msgid ""
"If the *data* elements are not comparable, the data can be wrapped in a "
"class that ignores the data item and only compares the priority number::"
msgstr ""
"Si les éléments de *data* ne sont pas comparables, les données peuvent être "
"enveloppées dans une classe qui ignore l'élément de données et ne compare "
"que l'ordre de priorité ::"

#: library/queue.rst:76
msgid ""
"Constructor for an unbounded :abbr:`FIFO (first-in, first-out)` queue. "
"Simple queues lack advanced functionality such as task tracking."
msgstr ""
"Constructeur d'une file illimitée :abbr:`FIFO (first-in, first-out)`. Les "
"simples files d'attente ne possèdent pas de fonctionnalités avancées telles "
"que le suivi des tâches."

#: library/queue.rst:84
msgid ""
"Exception raised when non-blocking :meth:`~Queue.get` (or :meth:`~Queue."
"get_nowait`) is called on a :class:`Queue` object which is empty."
msgstr ""
"Exception levée lorsque la méthode non bloquante :meth:`~Queue.get` (ou :"
"meth:`~Queue.get_nowait`) est appelée sur l'objet :class:`Queue` vide."

#: library/queue.rst:91
msgid ""
"Exception raised when non-blocking :meth:`~Queue.put` (or :meth:`~Queue."
"put_nowait`) is called on a :class:`Queue` object which is full."
msgstr ""
"Exception levée lorsque la méthode non bloquante :meth:`~Queue.put` (ou :"
"meth:`~Queue.put_nowait`) est appelée sur un objet :class:`Queue` plein."

#: library/queue.rst:99
msgid "Queue Objects"
msgstr "Objets ``Queue``"

#: library/queue.rst:101
msgid ""
"Queue objects (:class:`Queue`, :class:`LifoQueue`, or :class:"
"`PriorityQueue`) provide the public methods described below."
msgstr ""
"Les objets *Queue* (:class:`Queue`, :class:`LifoQueue` ou :class:"
"`PriorityQueue`) fournissent les méthodes publiques décrites ci-dessous."

#: library/queue.rst:107
msgid ""
"Return the approximate size of the queue.  Note, qsize() > 0 doesn't "
"guarantee that a subsequent get() will not block, nor will qsize() < maxsize "
"guarantee that put() will not block."
msgstr ""
"Renvoie la taille approximative de la file.  Notez que ``qsize() > 0`` ne "
"garantit pas qu'un ``get()`` ultérieur ne sera pas bloquant et que ``qsize() "
"< maxsize`` ne garantit pas non plus qu'un ``put()`` ne sera pas bloquant."

#: library/queue.rst:114
msgid ""
"Return ``True`` if the queue is empty, ``False`` otherwise.  If empty() "
"returns ``True`` it doesn't guarantee that a subsequent call to put() will "
"not block.  Similarly, if empty() returns ``False`` it doesn't guarantee "
"that a subsequent call to get() will not block."
msgstr ""
"Renvoie ``True`` si la file est vide, ``False`` sinon.  Si ``empty()`` "
"renvoie ``True``, cela ne garantit pas qu'un appel ultérieur à ``put()`` ne "
"sera pas bloquant.  Similairement, si ``empty()`` renvoie ``False``, cela ne "
"garantit pas qu'un appel ultérieur à ``get()`` ne sera pas bloquant."

#: library/queue.rst:122
msgid ""
"Return ``True`` if the queue is full, ``False`` otherwise.  If full() "
"returns ``True`` it doesn't guarantee that a subsequent call to get() will "
"not block.  Similarly, if full() returns ``False`` it doesn't guarantee that "
"a subsequent call to put() will not block."
msgstr ""
"Renvoie ``True`` si la file est pleine, ``False`` sinon.  Si ``full()`` "
"renvoie ``True``, cela ne garantit pas qu'un appel ultérieur à ``get()`` ne "
"sera pas bloquant.  Similairement, si ``full()`` retourne ``False``, cela ne "
"garantit pas qu'un appel ultérieur à ``put()`` ne sera pas bloquant."

#: library/queue.rst:130
#, fuzzy
msgid ""
"Put *item* into the queue.  If optional args *block* is true 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:`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:`Full` exception "
"(*timeout* is ignored in that case)."
msgstr ""
"Met *item* dans la file. Si les arguments optionnels *block* et *timeout* "
"sont respectivement ``True`` et ``None`` (les valeurs par défaut), la "
"méthode bloque si nécessaire jusqu'à ce qu'un emplacement libre soit "
"disponible. Si *timeout* est un nombre positif, elle bloque au plus "
"*timeout* secondes et lève l'exception :exc:`Full` s'il n'y avait pas "
"d'emplacement libre pendant cette période de temps. Sinon (*block* est "
"``False``), elle met un élément dans la file s'il y a un emplacement libre "
"immédiatement disponible. Si ce n'est pas le cas, elle lève l'exception :exc:"
"`Full` (*timeout* est ignoré dans ce cas)."

#: library/queue.rst:141
#, fuzzy
msgid "Equivalent to ``put(item, block=False)``."
msgstr "Équivalent à ``put(item, False)``."

#: library/queue.rst:258
msgid ""
"Remove and return an item from the queue.  If optional args *block* is true "
"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:`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:`Empty` exception (*timeout* is "
"ignored in that case)."
msgstr ""
"Retire et renvoie un élément de la file. Si les arguments optionnels *block* "
"et *timeout* valent respectivement ``True`` et ``None`` (les valeurs par "
"défaut), la méthode bloque si nécessaire jusqu'à ce qu'un élément soit "
"disponible. Si *timeout* est un entier positif, elle bloque au plus "
"*timeout* secondes et lève l'exception :exc:`Empty` s'il n'y avait pas "
"d'élément disponible pendant cette période de temps. Sinon (*block* vaut "
"``False``), elle renvoie un élément s'il y en a un immédiatement disponible. "
"Si ce n'est pas le cas, elle lève l'exception :exc:`Empty` (*timeout* est "
"ignoré dans ce cas)."

#: library/queue.rst:153
#, fuzzy
msgid ""
"Prior to 3.0 on POSIX systems, and for all versions on Windows, if *block* "
"is true and *timeout* is ``None``, this operation goes into an "
"uninterruptible wait on an underlying lock.  This means that no exceptions "
"can occur, and in particular a SIGINT will not trigger a :exc:"
"`KeyboardInterrupt`."
msgstr ""
"Avant Python 3.0 sur les systèmes POSIX, et pour toutes les versions sur "
"Windows, si *block* est vrai et *timeout* vaut ``None``, cette opération "
"rentre dans une attente ininterruptible sous un verrou. Cela veut dire "
"qu'aucune exception ne peut arriver et, en particulier, un *SIGINT* ne "
"déclenchera pas de :exc:`KeyboardInterrupt`."

#: library/queue.rst:268
msgid "Equivalent to ``get(False)``."
msgstr "Équivalent à ``get(False)``."

#: library/queue.rst:163
msgid ""
"Two methods are offered to support tracking whether enqueued tasks have been "
"fully processed by daemon consumer threads."
msgstr ""
"Deux méthodes sont proposées afin de savoir si les tâches mises dans la file "
"ont été entièrement traitées par les fils d'exécution consommateurs du démon."

#: library/queue.rst:169
msgid ""
"Indicate that a formerly enqueued task is complete.  Used by queue consumer "
"threads.  For each :meth:`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 mise dans la file est terminée. Utilisé "
"par les fils d'exécution consommateurs de la file. Pour chaque appel à :meth:"
"`get` effectué afin de récupérer une tâche, un appel ultérieur à :meth:"
"`task_done` informe la file que le traitement de la tâche est terminé."

#: library/queue.rst:173
msgid ""
"If a :meth:`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:`put` into the queue)."
msgstr ""
"Si un :meth:`join` est actuellement bloquant, on reprendra lorsque tous les "
"éléments auront été traités (ce qui signifie qu'un appel à :meth:`task_done` "
"a été effectué pour chaque élément qui a été :meth:`put` dans la file)."

#: library/queue.rst:177
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/queue.rst:183
msgid "Blocks 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é obtenus et "
"traités."

#: library/queue.rst:185
#, fuzzy
msgid ""
"The count of unfinished tasks goes up whenever an item is added to the "
"queue. The count goes down whenever a consumer thread 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:`join` "
"unblocks."
msgstr ""
"Le nombre de tâches inachevées augmente chaque fois qu'un élément est ajouté "
"à la file. Ce nombre diminue chaque fois qu'un fil d'exécution consommateur "
"appelle :meth:`task_done` pour indiquer que l'élément a été extrait et que "
"tout le travail à effectuer dessus est terminé. Lorsque le nombre de tâches "
"non terminées devient nul, :meth:`join` débloque."

#: library/queue.rst:191
msgid "Example of how to wait for enqueued tasks to be completed::"
msgstr ""
"Exemple montrant comment attendre que les tâches mises dans la file soient "
"terminées ::"

#: library/queue.rst:218
msgid "SimpleQueue Objects"
msgstr "Objets ``SimpleQueue``"

#: library/queue.rst:220
msgid ""
":class:`SimpleQueue` objects provide the public methods described below."
msgstr ""
"Les objets :class:`SimpleQueue` fournissent les méthodes publiques décrites "
"ci-dessous."

#: library/queue.rst:224
msgid ""
"Return the approximate size of the queue.  Note, qsize() > 0 doesn't "
"guarantee that a subsequent get() will not block."
msgstr ""
"Renvoie la taille approximative de la file. Notez que ``qsize() > 0`` ne "
"garantit pas qu'un ``get()`` ultérieur ne soit pas bloquant."

#: library/queue.rst:230
#, fuzzy
msgid ""
"Return ``True`` if the queue is empty, ``False`` otherwise.  If empty() "
"returns ``False`` it doesn't guarantee that a subsequent call to get() will "
"not block."
msgstr ""
"Renvoie ``True`` si la file est vide, ``False`` sinon. Si ``empty()`` "
"renvoie ``False``, cela ne garantit pas qu'un appel ultérieur à ``get()`` ne "
"soit pas bloquant."

#: library/queue.rst:237
msgid ""
"Put *item* into the queue.  The method never blocks and always succeeds "
"(except for potential low-level errors such as failure to allocate memory). "
"The optional args *block* and *timeout* are ignored and only provided for "
"compatibility with :meth:`Queue.put`."
msgstr ""
"Met *item* dans la file. La méthode ne bloque jamais et aboutit toujours "
"(sauf en cas de potentielles erreurs de bas niveau, telles qu'un échec "
"d'allocation de mémoire). Les arguments optionnels *block* et *timeout* sont "
"ignorés et fournis uniquement pour la compatibilité avec :meth:`Queue.put`."

#: library/queue.rst:243
msgid ""
"This method has a C implementation which is reentrant.  That is, a ``put()`` "
"or ``get()`` call can be interrupted by another ``put()`` call in the same "
"thread without deadlocking or corrupting internal state inside the queue.  "
"This makes it appropriate for use in destructors such as ``__del__`` methods "
"or :mod:`weakref` callbacks."
msgstr ""

#: library/queue.rst:252
#, fuzzy
msgid ""
"Equivalent to ``put(item, block=False)``, provided for compatibility with :"
"meth:`Queue.put_nowait`."
msgstr ""
"Équivalent de ``put(item)``, fourni pour la compatibilité avec :meth:`Queue."
"put_nowait`."

#: library/queue.rst:275
msgid "Class :class:`multiprocessing.Queue`"
msgstr "Classe :class:`multiprocessing.Queue`"

#: library/queue.rst:274
msgid ""
"A queue class for use in a multi-processing (rather than multi-threading) "
"context."
msgstr ""
"Une file à utiliser dans un contexte multi-processus (plutôt que *multi-"
"thread*)."

#: library/queue.rst:277
msgid ""
":class:`collections.deque` is an alternative implementation of unbounded "
"queues with fast atomic :meth:`~collections.deque.append` and :meth:"
"`~collections.deque.popleft` operations that do not require locking and also "
"support indexing."
msgstr ""
":class:`collections.deque` est une implémentation alternative de file non "
"bornée avec des méthodes :meth:`~collections.deque.append` et :meth:"
"`~collections.deque.popleft` rapides et atomiques ne nécessitant pas de "
"verrouillage et prenant également en charge l'indexation."

#~ msgid ""
#~ "Remove and return an item from the queue. If optional args *block* is "
#~ "true 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:`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:`Empty` exception "
#~ "(*timeout* is ignored in that case)."
#~ msgstr ""
#~ "Retire et renvoie un élément de la file. Si les arguments optionnels "
#~ "*block* et *timeout* valent respectivement ``True`` et ``None`` (les "
#~ "valeurs par défaut), la méthode bloque si nécessaire jusqu'à ce qu'un "
#~ "élément soit disponible. Si *timeout* est un entier positif, elle bloque "
#~ "au plus *timeout* secondes et lève l'exception :exc:`Empty` s'il n'y "
#~ "avait pas d'élément disponible pendant cette période de temps. Sinon "
#~ "(*block* vaut ``False``), elle renvoie un élément s'il y en a un "
#~ "immédiatement disponible. Si ce n'est pas le cas, elle lève l'exception :"
#~ "exc:`Empty` (*timeout* est ignoré dans ce cas)."