# 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: 2025-10-17 09:58+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 ""

"The full function signature is largely the same as that of the :class:`Task` "

"constructor (or factory) - all of the keyword arguments to this function are "

"passed through to that interface."

msgstr ""

#: library/asyncio-task.rst:250

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:254

msgid ""

"An optional keyword-only *eager_start* argument allows specifying if the "

"task should execute eagerly during the call to create_task, or be scheduled "

"later. If *eager_start* is not passed the mode set "

"by :meth:`loop.set_task_factory` will be used."

msgstr ""

#: library/asyncio-task.rst:259

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:265

#, fuzzy

msgid ""

":meth:`asyncio.TaskGroup.create_task` is a new alternative leveraging "

"structural concurrency; it allows for waiting for a group of related tasks "

"with strong safety guarantees."

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:271

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:1251

msgid "Added the *name* parameter."

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

# suit un :

#: library/asyncio-task.rst:1258

msgid "Added the *context* parameter."

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

# suit un :

#: library/asyncio-task.rst:299

#, fuzzy

msgid "Added the *eager_start* parameter by passing on all *kwargs*."

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

#: library/asyncio-task.rst:304

msgid "Task Cancellation"

msgstr "Annulation de tâche"

#: library/asyncio-task.rst:306

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:310

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:316

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:328

msgid "Task Groups"

msgstr "Groupes de tâches"

#: library/asyncio-task.rst:330

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:335

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:344

msgid ""

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

"of :func:`asyncio.create_task`. If the task group is inactive (e.g. not yet "

"entered, already finished, or in the process of shutting down), we will "

"close the given ``coro``."

msgstr ""

#: library/asyncio-task.rst:352

msgid "Close the given coroutine if the task group is not active."

msgstr ""

#: library/asyncio-task.rst:356

msgid "Passes on all *kwargs* to :meth:`loop.create_task`"

msgstr ""

#: library/asyncio-task.rst:564 library/asyncio-task.rst:795

#: library/asyncio-task.rst:862

msgid "Example::"

msgstr "Exemple ::"

#: library/asyncio-task.rst:366

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:373

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:383

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:390

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:396

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:408

msgid ""

"Task groups are careful not to mix up the internal cancellation used to "

"\"wake up\" their :meth:`~object.__aexit__` with cancellation requests for "

"the task in which they are running made by other parties. In particular, "

"when one task group is syntactically nested in another, and both experience "

"an exception in one of their child tasks simultaneously, the inner task "

"group will process its exceptions, and then the outer task group will "

"receive another cancellation and process its own exceptions."

msgstr ""

#: library/asyncio-task.rst:416

msgid ""

"In the case where a task group is cancelled externally and also must raise "

"an :exc:`ExceptionGroup`, it will call the parent "

"task's :meth:`~asyncio.Task.cancel` method. This ensures that "

"a :exc:`asyncio.CancelledError` will be raised at the next :keyword:`await`, "

"so the cancellation is not lost."

msgstr ""

#: library/asyncio-task.rst:422

msgid ""

"Task groups preserve the cancellation count reported "

"by :meth:`asyncio.Task.cancelling`."

msgstr ""

#: library/asyncio-task.rst:427

msgid ""

"Improved handling of simultaneous internal and external cancellations and "

"correct preservation of cancellation counts."

msgstr ""

#: library/asyncio-task.rst:431

msgid "Terminating a Task Group"

msgstr ""

#: library/asyncio-task.rst:433

msgid ""

"While terminating a task group is not natively supported by the standard "

"library, termination can be achieved by adding an exception-raising task to "

"the task group and ignoring the raised exception:"

msgstr ""

#: library/asyncio-task.rst:469

#, fuzzy

msgid "Expected output:"

msgstr "Sortie attendue ::"

#: library/asyncio-task.rst:478

msgid "Sleeping"

msgstr "Attente"

#: library/asyncio-task.rst:483

msgid "Block for *delay* seconds."

msgstr "Attend pendant *delay* secondes."

#: library/asyncio-task.rst:485

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:488

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:491

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:497

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:613 library/asyncio-task.rst:887

#: library/asyncio-task.rst:999

msgid "Removed the *loop* parameter."

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

#: library/asyncio-task.rst:518

msgid "Raises :exc:`ValueError` if *delay* is :data:`~math.nan`."

msgstr ""

#: library/asyncio-task.rst:523

msgid "Running Tasks Concurrently"

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

#: library/asyncio-task.rst:527

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:530

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:533

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:537

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:542

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:545

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:548

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:555

msgid ""

"A new alternative to create and run tasks concurrently and wait for their "

"completion is :class:`asyncio.TaskGroup`. *TaskGroup* provides stronger "

"safety guarantees than *gather* for scheduling a nesting of subtasks: if a "

"task (or a subtask, a task scheduled by a task) raises an exception, "

"*TaskGroup* will, while *gather* will not, cancel the remaining scheduled "

"tasks)."

msgstr ""

#: library/asyncio-task.rst:602

#, fuzzy

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:609

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:616

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:625

msgid "Eager Task Factory"

msgstr ""

#: library/asyncio-task.rst:629

msgid "A task factory for eager task execution."

msgstr ""

#: library/asyncio-task.rst:631

msgid ""

"When using this factory "

"(via :meth:`loop.set_task_factory(asyncio.eager_task_factory) "

"<loop.set_task_factory>`), coroutines begin execution synchronously "

"during :class:`Task` construction. Tasks are only scheduled on the event "

"loop if they block. This can be a performance improvement as the overhead of "

"loop scheduling is avoided for coroutines that complete synchronously."

msgstr ""

#: library/asyncio-task.rst:637

msgid ""

"A common example where this is beneficial is coroutines which employ caching "

"or memoization to avoid actual I/O when possible."

msgstr ""

#: library/asyncio-task.rst:642

msgid ""

"Immediate execution of the coroutine is a semantic change. If the coroutine "

"returns or raises, the task is never scheduled to the event loop. If the "

"coroutine execution blocks, the task is scheduled to the event loop. This "

"change may introduce behavior changes to existing applications. For example, "

"the application's task execution order is likely to change."

msgstr ""

#: library/asyncio-task.rst:653

msgid ""

"Create an eager task factory, similar to :func:`eager_task_factory`, using "

"the provided *custom_task_constructor* when creating a new task instead of "

"the default :class:`Task`."

msgstr ""

#: library/asyncio-task.rst:657

msgid ""

"*custom_task_constructor* must be a *callable* with the signature matching "

"the signature of :class:`Task.__init__ <Task>`. The callable must return "

"a :class:`asyncio.Task`-compatible object."

msgstr ""

#: library/asyncio-task.rst:661

msgid ""

"This function returns a *callable* intended to be used as a task factory of "

"an event loop via :meth:`loop.set_task_factory(factory) "

"<loop.set_task_factory>`)."

msgstr ""

#: library/asyncio-task.rst:668

msgid "Shielding From Cancellation"

msgstr "Protection contre l'annulation"

#: library/asyncio-task.rst:672

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:842

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:677

msgid "The statement::"

msgstr "L'instruction ::"

#: library/asyncio-task.rst:682

msgid "is equivalent to::"

msgstr "est équivalente à ::"

#: library/asyncio-task.rst:686

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:692

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:695

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:707

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:715

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:721

msgid "Timeouts"

msgstr "Délais d'attente"

#: library/asyncio-task.rst:725

#, fuzzy

msgid ""

"Return 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:729

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:734

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:743

#, 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:750

#, 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:755

#, fuzzy

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

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

#: library/asyncio-task.rst:766

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:771

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:774

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:777

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:778

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:783

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:788

msgid "Reschedule the timeout."

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

#: library/asyncio-task.rst:792

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:812

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:818

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:839

msgid ""

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

"timeout."

msgstr ""