# 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-07-23 14:38+0200\n"

"PO-Revision-Date: 2023-06-29 21:14+0200\n"

"Last-Translator: Christophe Nanteuil <christophe.nanteuil@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 3.2.2\n"

#: library/asyncio-task.rst:6

msgid "Coroutines and Tasks"

msgstr "Coroutines et tâches"

#: library/asyncio-task.rst:8

msgid ""

"This section outlines high-level asyncio APIs to work with coroutines and "

"Tasks."

msgstr ""

"Cette section donne un aperçu des API de haut-niveau du module *asyncio* "

"pour utiliser les coroutines et les tâches."

#: library/asyncio-task.rst:148

msgid "Coroutines"

msgstr "Coroutines"

#: library/asyncio-task.rst:21

msgid "**Source code:** :source:`Lib/asyncio/coroutines.py`"

msgstr "**Code source :** :source:`Lib/asyncio/coroutines.py`"

#: library/asyncio-task.rst:25

msgid ""

":term:`Coroutines <coroutine>` declared with the async/await syntax is the "

"preferred way of writing asyncio applications. For example, the following "

"snippet of code prints \"hello\", waits 1 second, and then prints \"world\"::"

msgstr ""

"Les :term:`coroutines <coroutine>` déclarées avec la syntaxe *async/await* "

"sont la manière privilégiée d’écrire des applications asynchrones. Par "

"exemple, l’extrait de code suivant affiche « hello », attend une seconde et "

"affiche ensuite « world » ::"

#: library/asyncio-task.rst:41

msgid ""

"Note that simply calling a coroutine will not schedule it to be executed::"

msgstr ""

"Remarquez que simplement appeler une coroutine ne la planifie pas pour "

"exécution ::"

#: library/asyncio-task.rst:47

msgid "To actually run a coroutine, asyncio provides the following mechanisms:"

msgstr ""

"Pour réellement exécuter une coroutine, *asyncio* fournit les mécanismes "

"suivants :"

#: library/asyncio-task.rst:49

msgid ""

"The :func:`asyncio.run` function to run the top-level entry point \"main()\" "

"function (see the above example.)"

msgstr ""

"La fonction :func:`asyncio.run` pour exécuter la fonction « main() », le "

"point d'entrée de haut-niveau (voir l'exemple ci-dessus)."

#: library/asyncio-task.rst:52

msgid ""

"Awaiting on a coroutine. The following snippet of code will print \"hello\" "

"after waiting for 1 second, and then print \"world\" after waiting for "

"*another* 2 seconds::"

msgstr ""

"Attendre une coroutine. Le morceau de code suivant attend une seconde, "

"affiche « hello », attend 2 secondes *supplémentaires*, puis affiche enfin "

"« world » ::"

#: library/asyncio-task.rst:73

msgid "Expected output::"

msgstr "Sortie attendue ::"

#: library/asyncio-task.rst:80

msgid ""

"The :func:`asyncio.create_task` function to run coroutines concurrently as "

"asyncio :class:`Tasks <Task>`."

msgstr ""

"La fonction :func:`asyncio.create_task` pour exécuter de manière concurrente "

"des coroutines en tant que :class:`tâches <Task>` *asyncio*."

#: library/asyncio-task.rst:83

msgid ""

"Let's modify the above example and run two ``say_after`` coroutines "

"*concurrently*::"

msgstr ""

"Modifions l'exemple ci-dessus et lançons deux coroutines ``say_after`` *de "

"manière concurrente* ::"

#: library/asyncio-task.rst:102

msgid ""

"Note that expected output now shows that the snippet runs 1 second faster "

"than before::"

msgstr ""

"La sortie attendue montre à présent que ce code s'exécute une seconde plus "

"rapidement que le précédent ::"

#: library/asyncio-task.rst:110

msgid ""

"The :class:`asyncio.TaskGroup` class provides a more modern alternative to :"

"func:`create_task`. Using this API, the last example becomes::"

msgstr ""

"La classe :class:`asyncio.TaskGroup` fournit une alternative plus moderne à :"

"func:`create_task`. En utilisant cette API, le dernier exemple devient ::"

#: library/asyncio-task.rst:128

msgid "The timing and output should be the same as for the previous version."

msgstr ""

"Le temps d'exécution et la sortie doivent être les mêmes que pour la version "

"précédente."

#: library/asyncio-task.rst:130

msgid ":class:`asyncio.TaskGroup`."

msgstr ":class:`asyncio.TaskGroup`."

#: library/asyncio-task.rst:137

msgid "Awaitables"

msgstr "*Attendables*"

#: library/asyncio-task.rst:139

msgid ""

"We say that an object is an **awaitable** object if it can be used in an :"

"keyword:`await` expression. Many asyncio APIs are designed to accept "

"awaitables."

msgstr ""

"Un objet est dit *attendable* (*awaitable* en anglais, c.-à-d. qui peut être "

"attendu) s'il peut être utilisé dans une expression :keyword:`await`. "

"Beaucoup d'API d'*asyncio* sont conçues pour accepter des *attendables*."

#: library/asyncio-task.rst:143

msgid ""

"There are three main types of *awaitable* objects: **coroutines**, "

"**Tasks**, and **Futures**."

msgstr ""

"Il existe trois types principaux d'*attendables* : les **coroutines**, les "

"**tâches** et les **futurs**."

#: library/asyncio-task.rst:149

msgid ""

"Python coroutines are *awaitables* and therefore can be awaited from other "

"coroutines::"

msgstr ""

"Les coroutines sont des *awaitables* et peuvent donc être attendues par "

"d'autres coroutines ::"

# suit un :

#: library/asyncio-task.rst:170

msgid ""

"In this documentation the term \"coroutine\" can be used for two closely "

"related concepts:"

msgstr ""

"dans cette documentation, le terme « coroutine » est utilisé pour désigner "

"deux concepts voisins :"

#: library/asyncio-task.rst:173

msgid "a *coroutine function*: an :keyword:`async def` function;"

msgstr "une *fonction coroutine* : une fonction :keyword:`async def` ;"

#: library/asyncio-task.rst:175

msgid ""

"a *coroutine object*: an object returned by calling a *coroutine function*."

msgstr "un *objet coroutine* : un objet renvoyé par une *fonction coroutine*."

#: library/asyncio-task.rst:180

msgid "Tasks"

msgstr "Tâches"

#: library/asyncio-task.rst:181

msgid "*Tasks* are used to schedule coroutines *concurrently*."

msgstr ""

"Les *tâches* servent à planifier des coroutines de façon à ce qu'elles "

"s'exécutent de manière concurrente."

#: library/asyncio-task.rst:183

msgid ""

"When a coroutine is wrapped into a *Task* with functions like :func:`asyncio."

"create_task` the coroutine is automatically scheduled to run soon::"

msgstr ""

"Lorsqu'une coroutine est encapsulée dans une *tâche* à l'aide de fonctions "

"comme :func:`asyncio.create_task`, la coroutine est automatiquement "

"planifiée pour s'exécuter prochainement ::"

#: library/asyncio-task.rst:205

msgid "Futures"

msgstr "Futurs"

#: library/asyncio-task.rst:206

msgid ""

"A :class:`Future` is a special **low-level** awaitable object that "

"represents an **eventual result** of an asynchronous operation."

msgstr ""

"Un :class:`Future` est un objet *attendable* spécial de **bas-niveau**, qui "

"représente le **résultat final** d'une opération asynchrone."

#: library/asyncio-task.rst:209

msgid ""

"When a Future object is *awaited* it means that the coroutine will wait "

"until the Future is resolved in some other place."

msgstr ""

"Quand un objet *Future* est *attendu*, cela signifie que la coroutine "

"attendra que ce futur soit résolu à un autre endroit."

#: library/asyncio-task.rst:212

msgid ""

"Future objects in asyncio are needed to allow callback-based code to be used "

"with async/await."

msgstr ""

"Les objets *Future* d'*asyncio* sont nécessaires pour permettre l'exécution "

"de code basé sur les fonctions de rappel avec la syntaxe *async* / *await*."

#: library/asyncio-task.rst:215

msgid ""

"Normally **there is no need** to create Future objects at the application "

"level code."

msgstr ""

"Il est normalement **inutile** de créer des objets *Future* dans la couche "

"applicative du code."

#: library/asyncio-task.rst:218

msgid ""

"Future objects, sometimes exposed by libraries and some asyncio APIs, can be "

"awaited::"

msgstr ""

"Les objets *Future*, parfois exposés par des bibliothèques et quelques API "

"d'*asyncio*, peuvent être attendus ::"

#: library/asyncio-task.rst:230

msgid ""

"A good example of a low-level function that returns a Future object is :meth:"

"`loop.run_in_executor`."

msgstr ""

":meth:`loop.run_in_executor` est l'exemple typique d'une fonction bas-niveau "

"renvoyant un objet *Future*."

#: library/asyncio-task.rst:235

msgid "Creating Tasks"

msgstr "Création de tâches"

#: library/asyncio-task.rst:237

msgid "**Source code:** :source:`Lib/asyncio/tasks.py`"

msgstr "**Code source :** :source:`Lib/asyncio/tasks.py`"

#: library/asyncio-task.rst:243

msgid ""

"Wrap the *coro* :ref:`coroutine <coroutine>` into a :class:`Task` and "

"schedule its execution. Return the Task object."

msgstr ""

"Encapsule la :ref:`coroutine <coroutine>` *coro* dans une tâche et la "

"planifie pour exécution. Renvoie l'objet :class:`Task`."

#: library/asyncio-task.rst:246

msgid ""

"If *name* is not ``None``, it is set as the name of the task using :meth:"

"`Task.set_name`."

msgstr ""

"Si *name* n’est pas ``None``, il est défini comme le nom de la tâche en "

"utilisant :meth:`Task.set_name`."

#: library/asyncio-task.rst:249

msgid ""

"An optional keyword-only *context* argument allows specifying a custom :"

"class:`contextvars.Context` for the *coro* to run in. The current context "

"copy is created when no *context* is provided."

msgstr ""

"L'argument (uniquement nommé) facultatif *context* permet de spécifier un :"

"class:`contextvars.Context` personnalisé pour la coroutine à exécuter. La "

"copie de contexte actuelle est créée lorsqu'aucun *context* n'est fourni."

#: library/asyncio-task.rst:253

msgid ""

"The task is executed in the loop returned by :func:`get_running_loop`, :exc:"

"`RuntimeError` is raised if there is no running loop in current thread."

msgstr ""

"La tâche est exécutée dans la boucle renvoyée par :func:"

"`get_running_loop` ; :exc:`RuntimeError` est levée s'il n'y a pas de boucle "

"en cours d'exécution dans le fil actuel."

#: library/asyncio-task.rst:259

#, fuzzy

msgid ""

":meth:`asyncio.TaskGroup.create_task` is a newer alternative that allows for "

"convenient waiting for a group of related tasks."

msgstr ""

":meth:`asyncio.TaskGroup.create_task` est une alternative plus récente qui "

"permet d'attendre facilement un groupe de tâches associées."

# suit un :

#: library/asyncio-task.rst:264

msgid ""

"Save a reference to the result of this function, to avoid a task "

"disappearing mid-execution. The event loop only keeps weak references to "

"tasks. A task that isn't referenced elsewhere may get garbage collected at "

"any time, even before it's done. For reliable \"fire-and-forget\" background "

"tasks, gather them in a collection::"

msgstr ""

"gardez une référence au résultat de cette fonction, pour éviter qu'une tâche "

"ne disparaisse en cours d'exécution. La boucle d'événements ne conserve que "

"les références faibles aux tâches. Une tâche qui n'est pas référencée "

"ailleurs peut être supprimée par le ramasse-miettes à tout moment, même "

"avant qu'elle ne soit terminée. Pour créer des tâches d'arrière-plan fiables "

"de type « lance et oublie », rassemblez-les dans une collection ::"

# suit un :

#: library/asyncio-task.rst:1013

msgid "Added the *name* parameter."

msgstr "ajout du paramètre *name*."

# suit un :

#: library/asyncio-task.rst:1020

msgid "Added the *context* parameter."

msgstr "ajout du paramètre *context*."

#: library/asyncio-task.rst:294

msgid "Task Cancellation"

msgstr "Annulation de tâche"

#: library/asyncio-task.rst:296

msgid ""

"Tasks can easily and safely be cancelled. When a task is cancelled, :exc:"

"`asyncio.CancelledError` will be raised in the task at the next opportunity."

msgstr ""

"Les tâches peuvent être annulées facilement et en toute sécurité. Lorsqu'une "

"tâche est annulée, :exc:`asyncio.CancelledError` est levée dans la tâche à "

"la première occasion."

#: library/asyncio-task.rst:300

msgid ""

"It is recommended that coroutines use ``try/finally`` blocks to robustly "

"perform clean-up logic. In case :exc:`asyncio.CancelledError` is explicitly "

"caught, it should generally be propagated when clean-up is complete. :exc:"

"`asyncio.CancelledError` directly subclasses :exc:`BaseException` so most "

"code will not need to be aware of it."

msgstr ""

"Il est recommandé que les coroutines utilisent des blocs ``try/finally`` "

"pour exécuter de manière robuste la logique de nettoyage. Dans le cas où :"

"exc:`asyncio.CancelledError` est explicitement interceptée, elle devrait "

"généralement être propagée lorsque le nettoyage est terminé. :exc:`asyncio."

"CancelledError` sous-classe directement :exc:`BaseException` donc la plupart "

"du code n'a pas besoin d'en être conscient."

#: library/asyncio-task.rst:306

msgid ""

"The asyncio components that enable structured concurrency, like :class:"

"`asyncio.TaskGroup` and :func:`asyncio.timeout`, are implemented using "

"cancellation internally and might misbehave if a coroutine swallows :exc:"

"`asyncio.CancelledError`. Similarly, user code should not generally call :"

"meth:`uncancel <asyncio.Task.uncancel>`. However, in cases when suppressing :"

"exc:`asyncio.CancelledError` is truly desired, it is necessary to also call "

"``uncancel()`` to completely remove the cancellation state."

msgstr ""

"Les composants *asyncio* qui permettent la concurrence structurée, comme :"

"class:`asyncio.TaskGroup` et :func:`asyncio.timeout`, sont implémentés en "

"utilisant l'annulation en interne et peuvent mal se comporter si une "

"coroutine ne propage pas :exc:`asyncio.CancelledError`. De même, le code "

"utilisateur ne doit généralement pas appeler :meth:`uncancel<asyncio.Task."

"uncancel>`. Cependant, dans les cas où la suppression de :exc:`asyncio."

"CancelledError` est vraiment souhaitée, il est également nécessaire "

"d'appeler ``uncancel()`` pour supprimer complètement l'état d'annulation."

#: library/asyncio-task.rst:318

msgid "Task Groups"

msgstr "Groupes de tâches"

#: library/asyncio-task.rst:320

msgid ""

"Task groups combine a task creation API with a convenient and reliable way "

"to wait for all tasks in the group to finish."

msgstr ""

"Les groupes de tâches combinent une API de création de tâches avec un moyen "

"pratique et fiable d'attendre la fin de toutes les tâches du groupe."

#: library/asyncio-task.rst:325

msgid ""

"An :ref:`asynchronous context manager <async-context-managers>` holding a "

"group of tasks. Tasks can be added to the group using :meth:`create_task`. "

"All tasks are awaited when the context manager exits."

msgstr ""

":ref:`Gestionnaire de contexte asynchrone <async-context-managers>` "

"responsable d’un groupe de tâches. Des tâches peuvent être ajoutées au "

"groupe en utilisant :meth:`create_task`. Toutes les tâches sont attendues à "

"la sortie du gestionnaire de contexte."

#: library/asyncio-task.rst:334

msgid ""

"Create a task in this task group. The signature matches that of :func:"

"`asyncio.create_task`."

msgstr ""

"Crée une tâche dans ce groupe de tâches. La signature correspond à celle de :"

"func:`asyncio.create_task`."

#: library/asyncio-task.rst:467 library/asyncio-task.rst:653

#: library/asyncio-task.rst:722 library/asyncio-task.rst:816

msgid "Example::"

msgstr "Exemple ::"

#: library/asyncio-task.rst:345

msgid ""

"The ``async with`` statement will wait for all tasks in the group to finish. "

"While waiting, new tasks may still be added to the group (for example, by "

"passing ``tg`` into one of the coroutines and calling ``tg.create_task()`` "

"in that coroutine). Once the last task has finished and the ``async with`` "

"block is exited, no new tasks may be added to the group."

msgstr ""

"L'instruction ``async with`` attend la fin de toutes les tâches du groupe. "

"Lors de l'attente, de nouvelles tâches peuvent encore être ajoutées au "

"groupe (par exemple, en passant ``tg`` dans l'une des coroutines et en "

"appelant ``tg.create_task()`` dans cette coroutine). Une fois que la "

"dernière tâche est terminée et que le bloc ``async with`` est quitté, aucune "

"nouvelle tâche ne peut être ajoutée au groupe."

#: library/asyncio-task.rst:352

msgid ""

"The first time any of the tasks belonging to the group fails with an "

"exception other than :exc:`asyncio.CancelledError`, the remaining tasks in "

"the group are cancelled. No further tasks can then be added to the group. At "

"this point, if the body of the ``async with`` statement is still active (i."

"e., :meth:`~object.__aexit__` hasn't been called yet), the task directly "

"containing the ``async with`` statement is also cancelled. The resulting :"

"exc:`asyncio.CancelledError` will interrupt an ``await``, but it will not "

"bubble out of the containing ``async with`` statement."

msgstr ""

"La première fois que l'une des tâches appartenant au groupe échoue avec une "

"exception autre que :exc:`asyncio.CancelledError`, les tâches restantes du "

"groupe sont annulées. Aucune autre tâche ne peut alors être ajoutée au "

"groupe. À ce stade, si le corps de l'instruction ``async with`` est toujours "

"actif (par exemple, :meth:`~object.__aexit__` n'a pas encore été appelé), la "

"tâche contenant directement l'instruction ``async with`` est également "

"annulée. Le résultat :exc:`asyncio.CancelledError` interrompt un ``await``, "

"mais il ne sort pas de l'instruction ``async with`` englobante."

#: library/asyncio-task.rst:362

msgid ""

"Once all tasks have finished, if any tasks have failed with an exception "

"other than :exc:`asyncio.CancelledError`, those exceptions are combined in "

"an :exc:`ExceptionGroup` or :exc:`BaseExceptionGroup` (as appropriate; see "

"their documentation) which is then raised."

msgstr ""

"Une fois toutes les tâches terminées, si des tâches ont échoué avec une "

"exception autre que :exc:`asyncio.CancelledError`, ces exceptions sont "

"combinées dans un :exc:`ExceptionGroup` ou :exc:`BaseExceptionGroup` (selon "

"le cas ; voir leur documentation) qui est ensuite levé."

#: library/asyncio-task.rst:369

msgid ""

"Two base exceptions are treated specially: If any task fails with :exc:"

"`KeyboardInterrupt` or :exc:`SystemExit`, the task group still cancels the "

"remaining tasks and waits for them, but then the initial :exc:"

"`KeyboardInterrupt` or :exc:`SystemExit` is re-raised instead of :exc:"

"`ExceptionGroup` or :exc:`BaseExceptionGroup`."

msgstr ""

"Deux exceptions de base sont traitées spécialement : si une tâche échoue "

"avec :exc:`KeyboardInterrupt` ou :exc:`SystemExit`, le groupe de tâches "

"annule toujours les tâches restantes et les attend, mais alors la :exc:"

"`KeyboardInterrupt` ou la :exc:`SystemExit` initiale est levée à nouveau au "

"lieu de :exc:`ExceptionGroup` ou :exc:`BaseExceptionGroup`."

#: library/asyncio-task.rst:375

msgid ""

"If the body of the ``async with`` statement exits with an exception (so :"

"meth:`~object.__aexit__` is called with an exception set), this is treated "

"the same as if one of the tasks failed: the remaining tasks are cancelled "

"and then waited for, and non-cancellation exceptions are grouped into an "

"exception group and raised. The exception passed into :meth:`~object."

"__aexit__`, unless it is :exc:`asyncio.CancelledError`, is also included in "

"the exception group. The same special case is made for :exc:"

"`KeyboardInterrupt` and :exc:`SystemExit` as in the previous paragraph."

msgstr ""

"Si le corps de l'instruction ``async with`` se termine avec une exception "

"(donc :meth:`~object.__aexit__` est appelé avec un ensemble d'exceptions), "

"cela est traité de la même manière que si l'une des tâches échouait : les "

"tâches restantes sont annulées puis attendues, et les exceptions de non-"

"annulation sont regroupées dans un groupe d'exceptions et levées. "

"L'exception transmise à :meth:`~object.__aexit__`, à moins qu'il ne s'agisse "

"de :exc:`asyncio.CancelledError`, est également incluse dans le groupe "

"d'exceptions. Le même cas spécial concerne :exc:`KeyboardInterrupt` et :exc:"

"`SystemExit` comme dans le paragraphe précédent."

#: library/asyncio-task.rst:389

msgid "Sleeping"

msgstr "Attente"

#: library/asyncio-task.rst:393

msgid "Block for *delay* seconds."

msgstr "Attend pendant *delay* secondes."

#: library/asyncio-task.rst:395

msgid ""

"If *result* is provided, it is returned to the caller when the coroutine "

"completes."

msgstr ""

"Si *result* est spécifié, il est renvoyé à l'appelant quand la coroutine se "

"termine."

#: library/asyncio-task.rst:398

msgid ""

"``sleep()`` always suspends the current task, allowing other tasks to run."

msgstr ""

"``sleep()`` suspend systématiquement la tâche courante, ce qui permet aux "

"autres tâches de s'exécuter."

#: library/asyncio-task.rst:401

msgid ""

"Setting the delay to 0 provides an optimized path to allow other tasks to "

"run. This can be used by long-running functions to avoid blocking the event "

"loop for the full duration of the function call."

msgstr ""

"Définir le délai sur 0 fournit un chemin optimisé pour permettre à d'autres "

"tâches de s'exécuter. Cela peut être utilisé par les fonctions de longue "

"durée pour éviter de bloquer la boucle d'événements pendant toute la durée "

"de l'appel de fonction."

#: library/asyncio-task.rst:407

msgid ""

"Example of coroutine displaying the current date every second for 5 seconds::"

msgstr ""

"Exemple d'une coroutine affichant la date toutes les secondes pendant 5 "

"secondes ::"

# suit un :

#: library/asyncio-task.rst:516 library/asyncio-task.rst:717

#: library/asyncio-task.rst:799 library/asyncio-task.rst:822

msgid "Removed the *loop* parameter."

msgstr "le paramètre *loop* a été enlevé."

#: library/asyncio-task.rst:430

msgid "Running Tasks Concurrently"

msgstr "Exécution de tâches de manière concurrente"

#: library/asyncio-task.rst:434

msgid ""

"Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws* sequence "

"*concurrently*."

msgstr ""

"Exécute les objets :ref:`awaitable <asyncio-awaitables>` de la séquence "

"*aws*, *de manière concurrente*."

#: library/asyncio-task.rst:437

msgid ""

"If any awaitable in *aws* is a coroutine, it is automatically scheduled as a "

"Task."

msgstr ""

"Si un *attendable* de *aws* est une coroutine, celui-ci est automatiquement "

"planifié comme une tâche *Task*."

#: library/asyncio-task.rst:440

msgid ""

"If all awaitables are completed successfully, the result is an aggregate "

"list of returned values. The order of result values corresponds to the "

"order of awaitables in *aws*."

msgstr ""

"Si tous les *awaitables* s'achèvent avec succès, le résultat est la liste "

"des valeurs renvoyées. L'ordre de cette liste correspond à l'ordre des "

"*awaitables* dans *aws*."

#: library/asyncio-task.rst:444

msgid ""

"If *return_exceptions* is ``False`` (default), the first raised exception is "

"immediately propagated to the task that awaits on ``gather()``. Other "

"awaitables in the *aws* sequence **won't be cancelled** and will continue to "

"run."

msgstr ""

"Si *return_exceptions* vaut ``False`` (valeur par défaut), la première "

"exception levée est immédiatement propagée vers la tâche en attente dans le "

"``gather()``. Les autres *attendables* dans la séquence *aws* **ne sont pas "

"annulés** et poursuivent leur exécution."

#: library/asyncio-task.rst:449

msgid ""

"If *return_exceptions* is ``True``, exceptions are treated the same as "

"successful results, and aggregated in the result list."

msgstr ""

"Si *return_exceptions* vaut ``True``, les exceptions sont traitées de la "

"même manière que les exécutions normales, et incluses dans la liste des "

"résultats."

#: library/asyncio-task.rst:452

msgid ""

"If ``gather()`` is *cancelled*, all submitted awaitables (that have not "

"completed yet) are also *cancelled*."

msgstr ""

"Si ``gather()`` est *annulé*, tous les *awaitables* en cours (ceux qui n'ont "

"pas encore fini de s'exécuter) sont également *annulés*."

#: library/asyncio-task.rst:455

msgid ""

"If any Task or Future from the *aws* sequence is *cancelled*, it is treated "

"as if it raised :exc:`CancelledError` -- the ``gather()`` call is **not** "

"cancelled in this case. This is to prevent the cancellation of one "

"submitted Task/Future to cause other Tasks/Futures to be cancelled."

msgstr ""

"Si n'importe quel *Task* ou *Future* de la séquence *aws* est *annulé*, il "

"est traité comme s'il avait levé :exc:`CancelledError` — l'appel à "

"``gather()`` n'est alors **pas** annulé. Ceci permet d'empêcher que "

"l'annulation d'une tâche ou d'un futur entraîne l'annulation des autres "

"tâches ou futurs."

#: library/asyncio-task.rst:462

msgid ""

"A more modern way to create and run tasks concurrently and wait for their "

"completion is :class:`asyncio.TaskGroup`."

msgstr ""

"Une façon plus moderne de créer et d'exécuter des tâches simultanément et "

"d'attendre leur achèvement est :class:`asyncio.TaskGroup`."

#: library/asyncio-task.rst:505

msgid ""

"If *return_exceptions* is False, cancelling gather() after it has been "

"marked done won't cancel any submitted awaitables. For instance, gather can "

"be marked done after propagating an exception to the caller, therefore, "

"calling ``gather.cancel()`` after catching an exception (raised by one of "

"the awaitables) from gather won't cancel any other awaitables."

msgstr ""

"Si *return_exceptions* est faux, l'annulation de la fonction *gather* après "

"qu'elle a été marquée comme terminée n'annule pas les *attendables* soumis. "

"Par exemple, *gather* peut être marquée comme terminée après avoir propagé "

"une exception à l'appelant, par conséquent, appeler ``gather.cancel()`` "

"après avoir intercepté une exception (levée par l'un des *attendables*) de "

"la collecte n'annule aucun autre *attendable*."

#: library/asyncio-task.rst:512

msgid ""

"If the *gather* itself is cancelled, the cancellation is propagated "

"regardless of *return_exceptions*."

msgstr ""

"Si *gather* est lui-même annulé, l'annulation est propagée indépendamment de "

"*return_exceptions*."

#: library/asyncio-task.rst:519

msgid ""

"Deprecation warning is emitted if no positional arguments are provided or "

"not all positional arguments are Future-like objects and there is no running "

"event loop."

msgstr ""

"Un avertissement d'obsolescence est émis si aucun argument positionnel n'est "

"fourni ou si tous les arguments positionnels ne sont pas des objets de type "

"Future et qu'il n'y a pas de boucle d'événements en cours d'exécution."

#: library/asyncio-task.rst:526

msgid "Shielding From Cancellation"

msgstr "Protection contre l'annulation"

#: library/asyncio-task.rst:530

msgid ""

"Protect an :ref:`awaitable object <asyncio-awaitables>` from being :meth:"

"`cancelled <Task.cancel>`."

msgstr ""

"Empêche qu'un objet :ref:`awaitable <asyncio-awaitables>` puisse être :meth:"

"`annulé <Task.cancel>`."

#: library/asyncio-task.rst:699

msgid "If *aw* is a coroutine it is automatically scheduled as a Task."

msgstr ""

"Si *aw* est une coroutine, elle est planifiée automatiquement comme une "

"tâche."

#: library/asyncio-task.rst:535

msgid "The statement::"

msgstr "L'instruction ::"

#: library/asyncio-task.rst:540

msgid "is equivalent to::"

msgstr "est équivalente à ::"

#: library/asyncio-task.rst:544

msgid ""

"*except* that if the coroutine containing it is cancelled, the Task running "

"in ``something()`` is not cancelled. From the point of view of "

"``something()``, the cancellation did not happen. Although its caller is "

"still cancelled, so the \"await\" expression still raises a :exc:"

"`CancelledError`."

msgstr ""

"*à la différence près* que, si la coroutine qui la contient est annulée, la "

"tâche s'exécutant dans ``something()`` n'est pas annulée. Du point de vue de "

"``something()``, il n'y a pas eu d'annulation. Cependant, son appelant est "

"bien annulé, donc l'expression *await* lève bien une :exc:`CancelledError`."

#: library/asyncio-task.rst:550

msgid ""

"If ``something()`` is cancelled by other means (i.e. from within itself) "

"that would also cancel ``shield()``."

msgstr ""

"Si ``something()`` est annulée d'une autre façon (c.-à-d. depuis elle-même) "

"ceci annule également ``shield()``."

#: library/asyncio-task.rst:553

msgid ""

"If it is desired to completely ignore cancellation (not recommended) the "

"``shield()`` function should be combined with a try/except clause, as "

"follows::"

msgstr ""

"Pour ignorer complètement l'annulation (déconseillé), la fonction "

"``shield()`` peut être combinée à une clause *try* / *except*, comme dans le "

"code ci-dessous ::"

# suit un :

#: library/asyncio-task.rst:565

msgid ""

"Save a reference to tasks passed to this function, to avoid a task "

"disappearing mid-execution. The event loop only keeps weak references to "

"tasks. A task that isn't referenced elsewhere may get garbage collected at "

"any time, even before it's done."

msgstr ""

"sauvegardez une référence aux tâches passées à cette fonction, pour éviter "

"qu'une tâche ne disparaisse en cours d'exécution. La boucle d'événements ne "

"conserve que les références faibles aux tâches. Une tâche qui n'est pas "

"référencée ailleurs peut faire l'objet d'une suppression par le ramasse-"

"miettes à tout moment, même avant qu'elle ne soit terminée."

# suit un :

#: library/asyncio-task.rst:573

msgid ""

"Deprecation warning is emitted if *aw* is not Future-like object and there "

"is no running event loop."

msgstr ""

"un avertissement d'obsolescence est émis si *aw* n'est pas un objet de type "

"*future* et qu'il n'y a pas de boucle d'événement en cours d'exécution."

#: library/asyncio-task.rst:579

msgid "Timeouts"

msgstr "Délais d'attente"

#: library/asyncio-task.rst:583

msgid ""

"An :ref:`asynchronous context manager <async-context-managers>` that can be "

"used to limit the amount of time spent waiting on something."

msgstr ""

":ref:`Gestionnaire de contexte asynchrone <async-context-managers>` qui peut "

"être utilisé pour limiter le temps passé à attendre quelque chose."

#: library/asyncio-task.rst:587

msgid ""

"*delay* can either be ``None``, or a float/int number of seconds to wait. If "

"*delay* is ``None``, no time limit will be applied; this can be useful if "

"the delay is unknown when the context manager is created."

msgstr ""

"*delay* peut-être soit ``None``, soit le nombre de secondes (entier ou "

"décimal) d'attente. Si *delay* vaut ``None``, aucune limite n'est "

"appliquée ; cela peut être utile lorsque le délai d'attente est inconnu au "

"moment de la création du gestionnaire de contexte."

#: library/asyncio-task.rst:592

msgid ""

"In either case, the context manager can be rescheduled after creation using :"

"meth:`Timeout.reschedule`."

msgstr ""

"Dans les deux cas, le gestionnaire de contexte peut être redéfini après sa "

"création en utilisant :meth:`Timeout.reschedule`."

#: library/asyncio-task.rst:601

#, fuzzy

msgid ""

"If ``long_running_task`` takes more than 10 seconds to complete, the context "

"manager will cancel the current task and handle the resulting :exc:`asyncio."

"CancelledError` internally, transforming it into a :exc:`TimeoutError` which "

"can be caught and handled."

msgstr ""

"Si ``long_running_task`` prend plus de 10 secondes pour se terminer, le "

"gestionnaire de contexte annule la tâche en cours et traite l'erreur :exc:"

"`asyncio.CancelledError` en interne, la transformant en une :exc:`asyncio."

"TimeoutError` qui peut être interceptée et gérée."

# suit un :

#: library/asyncio-task.rst:608

#, fuzzy

msgid ""

"The :func:`asyncio.timeout` context manager is what transforms the :exc:"

"`asyncio.CancelledError` into a :exc:`TimeoutError`, which means the :exc:"

"`TimeoutError` can only be caught *outside* of the context manager."

msgstr ""

"le gestionnaire de contexte :func:`asyncio.timeout` est ce qui transforme "

"la :exc:`asyncio.CancelledError` en une :exc:`asyncio.TimeoutError`, ce qui "

"signifie que la :exc:`asyncio.TimeoutError` ne peut être interceptée qu' *en "

"dehors* du gestionnaire de contexte."

#: library/asyncio-task.rst:613

#, fuzzy

msgid "Example of catching :exc:`TimeoutError`::"

msgstr "Exemple de capture :exc:`asyncio.TimeoutError` ::"

#: library/asyncio-task.rst:624

msgid ""

"The context manager produced by :func:`asyncio.timeout` can be rescheduled "

"to a different deadline and inspected."

msgstr ""

"Le gestionnaire de contexte produit par :func:`asyncio.timeout` peut être "

"reprogrammé à une échéance différente et inspecté."

#: library/asyncio-task.rst:629

msgid ""

"An :ref:`asynchronous context manager <async-context-managers>` for "

"cancelling overdue coroutines."

msgstr ""

":ref:`Gestionnaire de contexte asynchrone <async-context-managers>` pour "

"annuler les coroutines en retard."

#: library/asyncio-task.rst:632

msgid ""

"``when`` should be an absolute time at which the context should time out, as "

"measured by the event loop's clock:"

msgstr ""

"``when`` doit être un temps absolu au bout duquel le contexte doit expirer, "

"tel que mesuré par l'horloge de la boucle d'événements :"

#: library/asyncio-task.rst:635

msgid "If ``when`` is ``None``, the timeout will never trigger."

msgstr "Si ``when`` vaut ``None``, le délai maximal ne se déclenche jamais."

#: library/asyncio-task.rst:636

msgid ""

"If ``when < loop.time()``, the timeout will trigger on the next iteration of "

"the event loop."

msgstr ""

"Si ``when < loop.time()``, le délai maximal se déclenche à la prochaine "

"itération de la boucle d'événement."

#: library/asyncio-task.rst:641

msgid ""

"Return the current deadline, or ``None`` if the current deadline is not set."

msgstr ""

"Renvoie la limite de temps d'exécution définie actuellement, ou ``None`` "

"s'il n'y en a pas."

#: library/asyncio-task.rst:646

msgid "Reschedule the timeout."

msgstr "Reprogramme le délai d'attente."

#: library/asyncio-task.rst:650

msgid "Return whether the context manager has exceeded its deadline (expired)."

msgstr ""

"Renvoie si le gestionnaire de contexte a dépassé son délai (c.-à-d. s'il a "

"expiré)."

#: library/asyncio-task.rst:670

msgid "Timeout context managers can be safely nested."

msgstr ""

"Les gestionnaires de contexte de délai maximal peuvent être imbriqués en "

"toute sécurité."

#: library/asyncio-task.rst:676

msgid ""

"Similar to :func:`asyncio.timeout`, except *when* is the absolute time to "

"stop waiting, or ``None``."

msgstr ""

"Semblable à :func:`asyncio.timeout`, sauf que *when* est le temps absolu "

"pour arrêter d'attendre, ou ``None``."

#: library/asyncio-task.rst:696

msgid ""

"Wait for the *aw* :ref:`awaitable <asyncio-awaitables>` to complete with a "

"timeout."

msgstr ""

"Attend la fin de l':ref:`awaitable <asyncio-awaitables>` *aw* avec délai "

"d'attente."

#: library/asyncio-task.rst:701

msgid ""

"*timeout* can either be ``None`` or a float or int number of seconds to wait "

"for. If *timeout* is ``None``, block until the future completes."

msgstr ""

"*timeout* peut-être soit ``None``, soit le nombre de secondes (entier ou "

"décimal) d'attente. Si *timeout* vaut ``None``, la fonction s'interrompt "

"jusqu'à ce que le futur s'achève."

#: library/asyncio-task.rst:705

msgid ""

"If a timeout occurs, it cancels the task and raises :exc:`TimeoutError`."

msgstr ""

"Si le délai d'attente maximal est dépassé, la tâche est annulée et "

"l'exception :exc:`TimeoutError` est levée."

#: library/asyncio-task.rst:708

msgid ""

"To avoid the task :meth:`cancellation <Task.cancel>`, wrap it in :func:"

"`shield`."

msgstr ""

"Pour empêcher :meth:`l'annulation <Task.cancel>` de la tâche, il est "

"nécessaire de l'encapsuler dans une fonction :func:`shield`."

#: library/asyncio-task.rst:711

msgid ""

"The function will wait until the future is actually cancelled, so the total "

"wait time may exceed the *timeout*. If an exception happens during "

"cancellation, it is propagated."

msgstr ""

"Cette fonction attend que le futur soit réellement annulé, donc le temps "

"d'attente total peut être supérieur à *timeout*. Si une exception se produit "

"lors de l'annulation, elle est propagée."

#: library/asyncio-task.rst:715

msgid "If the wait is cancelled, the future *aw* is also cancelled."

msgstr "Si l'attente est annulée, le futur *aw* est également annulé."

#: library/asyncio-task.rst:742

msgid ""

"When *aw* is cancelled due to a timeout, ``wait_for`` waits for *aw* to be "

"cancelled. Previously, it raised :exc:`TimeoutError` immediately."

msgstr ""

"Si le dépassement du délai d'attente maximal provoque l'annulation de *aw*, "

"``wait_for`` attend que *aw* soit annulée. Auparavant, l'exception :exc:"

"`TimeoutError` était immédiatement levée."

#: library/asyncio-task.rst:752

msgid "Waiting Primitives"

msgstr "Primitives d'attente"

#: library/asyncio-task.rst:756

msgid ""

"Run :class:`~asyncio.Future` and :class:`~asyncio.Task` instances in the "

"*aws* iterable concurrently and block until the condition specified by "

"*return_when*."

msgstr ""

"Exécute les instances :class:`~asyncio.Future` et :class:`~asyncio.Task` de "

"l'itérable *aws* de manière concurrente, et s'interrompt jusqu'à ce que la "

"condition décrite dans *return_when* soit vraie."

#: library/asyncio-task.rst:760

#, fuzzy

msgid ""

"The *aws* iterable must not be empty and generators yielding tasks are not "

"accepted."

msgstr "L'itérable *aws* ne doit pas être vide."

#: library/asyncio-task.rst:762

msgid "Returns two sets of Tasks/Futures: ``(done, pending)``."

msgstr "Renvoie deux ensembles de *Tasks* / *Futures* : ``(done, pending)``."

#: library/asyncio-task.rst:764

msgid "Usage::"

msgstr "Utilisation ::"

#: library/asyncio-task.rst:768

msgid ""

"*timeout* (a float or int), if specified, can be used to control the maximum "

"number of seconds to wait before returning."

msgstr ""

"*timeout* (entier ou décimal), si précisé, peut-être utilisé pour contrôler "

"le nombre maximal de secondes d'attente avant de se terminer."

#: library/asyncio-task.rst:771

msgid ""

"Note that this function does not raise :exc:`TimeoutError`. Futures or Tasks "

"that aren't done when the timeout occurs are simply returned in the second "

"set."

msgstr ""

"Cette fonction ne lève pas :exc:`TimeoutError`. Les futurs et les tâches qui "

"ne sont pas finis quand le délai d'attente maximal est dépassé sont tout "

"simplement renvoyés dans le second ensemble."

#: library/asyncio-task.rst:775

msgid ""

"*return_when* indicates when this function should return. It must be one of "

"the following constants:"

msgstr ""

"*return_when* indique quand la fonction doit se terminer. Il peut prendre "

"les valeurs suivantes :"

#: library/asyncio-task.rst:781

msgid "Constant"

msgstr "Constante"

#: library/asyncio-task.rst:781

msgid "Description"

msgstr "Description"

#: library/asyncio-task.rst:783

msgid ":const:`FIRST_COMPLETED`"

msgstr ":const:`FIRST_COMPLETED`"

#: library/asyncio-task.rst:783

msgid "The function will return when any future finishes or is cancelled."

msgstr ""

"La fonction se termine lorsque n'importe quel futur se termine ou est annulé."

#: library/asyncio-task.rst:786

msgid ":const:`FIRST_EXCEPTION`"

msgstr ":const:`FIRST_EXCEPTION`"

#: library/asyncio-task.rst:786

msgid ""

"The function will return when any future finishes by raising an exception. "

"If no future raises an exception then it is equivalent to :const:"

"`ALL_COMPLETED`."

msgstr ""

"La fonction se termine lorsque n'importe quel futur se termine en levant une "

"exception. Si aucun *futur* ne lève d'exception, équivaut à :const:"

"`ALL_COMPLETED`."

#: library/asyncio-task.rst:792

msgid ":const:`ALL_COMPLETED`"

msgstr ":const:`ALL_COMPLETED`"