# 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 \n" "Language-Team: FRENCH \n" "Language: fr\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" "X-Generator: Poedit 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 ` 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 ` 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 `." msgstr "" "La fonction :func:`asyncio.create_task` pour exécuter de manière concurrente " "des coroutines en tant que :class:`tâches ` *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 ` into a :class:`Task` and " "schedule its execution. Return the Task object." msgstr "" "Encapsule la :ref:`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 `. 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`. 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 ` 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 ` " "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 ` in the *aws* sequence " "*concurrently*." msgstr "" "Exécute les objets :ref:`awaitable ` 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 ` from being :meth:" "`cancelled `." msgstr "" "Empêche qu'un objet :ref:`awaitable ` puisse être :meth:" "`annulé `." #: 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 ` that can be " "used to limit the amount of time spent waiting on something." msgstr "" ":ref:`Gestionnaire de contexte asynchrone ` 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 ` for " "cancelling overdue coroutines." msgstr "" ":ref:`Gestionnaire de contexte asynchrone ` 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 ` to complete with a " "timeout." msgstr "" "Attend la fin de l':ref:`awaitable ` *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 `, wrap it in :func:" "`shield`." msgstr "" "Pour empêcher :meth:`l'annulation ` 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`" #: library/asyncio-task.rst:792 msgid "The function will return when all futures finish or are cancelled." msgstr "" "La fonction se termine lorsque les *futurs* sont tous finis ou annulés." #: library/asyncio-task.rst:796 msgid "" "Unlike :func:`~asyncio.wait_for`, ``wait()`` does not cancel the futures " "when a timeout occurs." msgstr "" "À la différence de :func:`~asyncio.wait_for`, ``wait()`` n'annule pas les " "futurs quand le délai d'attente est dépassé." #: library/asyncio-task.rst:802 msgid "Passing coroutine objects to ``wait()`` directly is forbidden." msgstr "Passer directement des objets coroutines à ``wait()`` est interdit." #: library/asyncio-task.rst:807 #, fuzzy msgid "" "Run :ref:`awaitable objects ` in the *aws* iterable " "concurrently. Generators yielding tasks are not accepted as *aws* iterable. " "Return an iterator of coroutines. Each coroutine returned can be awaited to " "get the earliest next result from the iterable of the remaining awaitables." msgstr "" "Exécute les objets :ref:`attendables ` de l'itérable " "*aws* de manière concurrente. Renvoie un itérateur sur des coroutines. " "Chaque coroutine renvoyée peut être attendue pour obtenir le premier " "résultat suivant de l'ensemble des *attendables* restants." #: library/asyncio-task.rst:813 msgid "" "Raises :exc:`TimeoutError` if the timeout occurs before all Futures are done." msgstr "" "Lève une exception :exc:`TimeoutError` si le délai d'attente est dépassé " "avant que tous les futurs ne soient achevés." #: library/asyncio-task.rst:825 msgid "" "Deprecation warning is emitted if not all awaitable objects in the *aws* " "iterable are Future-like objects and there is no running event loop." msgstr "" "Un avertissement d'obsolescence est émis si tous les objets en attente dans " "l'itérable *aws* ne sont pas des objets de type *Future* et qu'il n'y a pas " "de boucle d'événement en cours d'exécution." #: library/asyncio-task.rst:831 msgid "Running in Threads" msgstr "Exécution dans des fils d'exécution (*threads*)" #: library/asyncio-task.rst:835 msgid "Asynchronously run function *func* in a separate thread." msgstr "" "Exécute la fonction *func* de manière asynchrone dans un fil d'exécution " "séparé." #: library/asyncio-task.rst:837 msgid "" "Any \\*args and \\*\\*kwargs supplied for this function are directly passed " "to *func*. Also, the current :class:`contextvars.Context` is propagated, " "allowing context variables from the event loop thread to be accessed in the " "separate thread." msgstr "" "Tous les *\\*args* et *\\*\\*kwargs* fournis à cette fonction sont " "directement passés à *func*. De plus, le :class:`contextvars.Context` actuel " "est propagé, ce qui permet d'accéder aux variables de contexte du fil de " "boucle d'événements dans le fil séparé." #: library/asyncio-task.rst:842 msgid "" "Return a coroutine that can be awaited to get the eventual result of *func*." msgstr "" "Renvoie une coroutine qui peut être attendue pour obtenir le résultat " "éventuel de *func*." #: library/asyncio-task.rst:844 msgid "" "This coroutine function is primarily intended to be used for executing IO-" "bound functions/methods that would otherwise block the event loop if they " "were run in the main thread. For example::" msgstr "" "Cette fonction coroutine est principalement destinée à être utilisée pour " "exécuter des fonctions/méthodes faisant beaucoup d'entrées-sorties et qui " "bloqueraient autrement la boucle d'événements si elles étaient exécutées " "dans le fil d'exécution principal. Par exemple ::" #: library/asyncio-task.rst:874 msgid "" "Directly calling ``blocking_io()`` in any coroutine would block the event " "loop for its duration, resulting in an additional 1 second of run time. " "Instead, by using ``asyncio.to_thread()``, we can run it in a separate " "thread without blocking the event loop." msgstr "" "Appeler directement ``blocking_io()`` dans n'importe quelle coroutine " "bloquerait la boucle d'événements pendant sa durée, ce qui entraînerait une " "seconde supplémentaire de temps d'exécution. Au lieu de cela, en utilisant " "``asyncio.to_thread()``, nous pouvons l'exécuter dans un fil d'exécution " "séparé sans bloquer la boucle d'événements." # suit un : #: library/asyncio-task.rst:881 msgid "" "Due to the :term:`GIL`, ``asyncio.to_thread()`` can typically only be used " "to make IO-bound functions non-blocking. However, for extension modules that " "release the GIL or alternative Python implementations that don't have one, " "``asyncio.to_thread()`` can also be used for CPU-bound functions." msgstr "" "en raison du :term:`GIL`, ``asyncio.to_thread()`` ne peut généralement être " "utilisée que pour rendre les fonctions faisant beaucoup d'entrées-sorties " "non bloquantes. Cependant, pour les modules d'extension qui relâchent le GIL " "ou les implémentations Python alternatives qui n'en ont pas, ``asyncio." "to_thread()`` peut également être utilisée pour les fonctions qui " "sollicitent beaucoup le processeur." #: library/asyncio-task.rst:890 msgid "Scheduling From Other Threads" msgstr "Planification depuis d'autres fils d'exécution" #: library/asyncio-task.rst:894 msgid "Submit a coroutine to the given event loop. Thread-safe." msgstr "" "Enregistre une coroutine dans la boucle d'exécution actuelle. Cette " "opération est compatible avec les programmes à multiples fils d'exécution " "(*thread-safe*)." #: library/asyncio-task.rst:896 msgid "" "Return a :class:`concurrent.futures.Future` to wait for the result from " "another OS thread." msgstr "" "Renvoie un :class:`concurrent.futures.Future` pour attendre le résultat d'un " "autre fil d'exécution du système d'exploitation." #: library/asyncio-task.rst:899 msgid "" "This function is meant to be called from a different OS thread than the one " "where the event loop is running. Example::" msgstr "" "Cette fonction est faite pour être appelée par un fil d'exécution distinct " "de celui dans laquelle la boucle d'événement s'exécute. Exemple ::" #: library/asyncio-task.rst:911 msgid "" "If an exception is raised in the coroutine, the returned Future will be " "notified. It can also be used to cancel the task in the event loop::" msgstr "" "Si une exception est levée dans une coroutine, le futur renvoyé en sera " "averti. Elle peut également être utilisée pour annuler la tâche de la boucle " "d'événement ::" #: library/asyncio-task.rst:925 msgid "" "See the :ref:`concurrency and multithreading ` " "section of the documentation." msgstr "" "Voir la section :ref:`exécution concurrente et multi-fils d'exécution " "` de la documentation." #: library/asyncio-task.rst:928 msgid "" "Unlike other asyncio functions this function requires the *loop* argument to " "be passed explicitly." msgstr "" "À la différence des autres fonctions d'*asyncio*, cette fonction requiert " "que *loop* soit passé de manière explicite." #: library/asyncio-task.rst:935 msgid "Introspection" msgstr "Introspection" #: library/asyncio-task.rst:940 msgid "" "Return the currently running :class:`Task` instance, or ``None`` if no task " "is running." msgstr "" "Renvoie l'instance de la :class:`Task` en cours d'exécution, ou ``None`` " "s'il n'y a pas de tâche en cours." #: library/asyncio-task.rst:943 msgid "" "If *loop* is ``None`` :func:`get_running_loop` is used to get the current " "loop." msgstr "" "Si *loop* vaut ``None``, :func:`get_running_loop` est appelée pour récupérer " "la boucle en cours d'exécution." #: library/asyncio-task.rst:951 msgid "Return a set of not yet finished :class:`Task` objects run by the loop." msgstr "" "Renvoie l'ensemble des :class:`Task` non terminés en cours d'exécution dans " "la boucle." #: library/asyncio-task.rst:954 msgid "" "If *loop* is ``None``, :func:`get_running_loop` is used for getting current " "loop." msgstr "" "Si *loop* vaut ``None``, :func:`get_running_loop` est appelée pour récupérer " "la boucle en cours d'exécution." #: library/asyncio-task.rst:962 msgid "Return ``True`` if *obj* is a coroutine object." msgstr "Renvoie ``True`` si *obj* est un objet coroutine." #: library/asyncio-task.rst:968 msgid "Task Object" msgstr "Objets *Task*" #: library/asyncio-task.rst:972 msgid "" "A :class:`Future-like ` object that runs a Python :ref:`coroutine " "`. Not thread-safe." msgstr "" "Objet compatible avec :class:`Future ` qui exécute une :ref:" "`coroutine ` Python. Cet objet n'est pas utilisable dans des " "programmes à fils d'exécution multiples." #: library/asyncio-task.rst:975 msgid "" "Tasks are used to run coroutines in event loops. If a coroutine awaits on a " "Future, the Task suspends the execution of the coroutine and waits for the " "completion of the Future. When the Future is *done*, the execution of the " "wrapped coroutine resumes." msgstr "" "Les tâches servent à exécuter des coroutines dans des boucles d'événements. " "Si une coroutine attend un futur, la tâche interrompt son exécution et " "attend la fin de ce *futur*. Quand celui-ci est terminé, l'exécution de la " "coroutine encapsulée reprend." #: library/asyncio-task.rst:981 msgid "" "Event loops use cooperative scheduling: an event loop runs one Task at a " "time. While a Task awaits for the completion of a Future, the event loop " "runs other Tasks, callbacks, or performs IO operations." msgstr "" "Les boucles d'événement fonctionnent de manière *coopérative* : une boucle " "d'événement exécute une tâche à la fois. Quand une tâche attend la fin d'un " "futur, la boucle d'événement exécute d'autres tâches, des fonctions de " "rappel, ou effectue des opérations d'entrées-sorties." #: library/asyncio-task.rst:986 msgid "" "Use the high-level :func:`asyncio.create_task` function to create Tasks, or " "the low-level :meth:`loop.create_task` or :func:`ensure_future` functions. " "Manual instantiation of Tasks is discouraged." msgstr "" "La fonction de haut niveau :func:`asyncio.create_task` et les fonctions de " "bas-niveau :meth:`loop.create_task` ou :func:`ensure_future` permettent de " "créer des tâches. Il est déconseillé d'instancier manuellement des objets " "*Task*." #: library/asyncio-task.rst:991 msgid "" "To cancel a running Task use the :meth:`cancel` method. Calling it will " "cause the Task to throw a :exc:`CancelledError` exception into the wrapped " "coroutine. If a coroutine is awaiting on a Future object during " "cancellation, the Future object will be cancelled." msgstr "" "La méthode :meth:`cancel` d'une tâche en cours d'exécution permet d'annuler " "celle-ci. L'appel de cette méthode force la tâche à lever l'exception :exc:" "`CancelledError` dans la coroutine encapsulée. Si la coroutine attendait un " "*futur* au moment de l'annulation, celui-ci est annulé." #: library/asyncio-task.rst:996 msgid "" ":meth:`cancelled` can be used to check if the Task was cancelled. The method " "returns ``True`` if the wrapped coroutine did not suppress the :exc:" "`CancelledError` exception and was actually cancelled." msgstr "" "La méthode :meth:`cancelled` permet de vérifier si la tâche a été annulée. " "Elle renvoie ``True`` si la coroutine encapsulée n'a pas ignoré l'exception :" "exc:`CancelledError` et a bien été annulée." #: library/asyncio-task.rst:1001 msgid "" ":class:`asyncio.Task` inherits from :class:`Future` all of its APIs except :" "meth:`Future.set_result` and :meth:`Future.set_exception`." msgstr "" ":class:`asyncio.Task` hérite de :class:`Future`, de toute son API, à " "l'exception de :meth:`Future.set_result` et de :meth:`Future.set_exception`." #: library/asyncio-task.rst:1005 #, fuzzy msgid "" "An optional keyword-only *context* argument allows specifying a custom :" "class:`contextvars.Context` for the *coro* to run in. If no *context* is " "provided, the Task copies the current context and later runs its coroutine " "in the copied context." 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." # suit un : #: library/asyncio-task.rst:1010 msgid "Added support for the :mod:`contextvars` module." msgstr "ajout du support du module :mod:`contextvars`." # suit un : #: library/asyncio-task.rst:1016 msgid "" "Deprecation warning is emitted if *loop* is not specified and there is no " "running event loop." msgstr "" "un avertissement d'obsolescence est émis si *loop* n'est pas spécifié et " "qu'il n'y a pas de boucle d'événement en cours d'exécution." #: library/asyncio-task.rst:1025 msgid "Return ``True`` if the Task is *done*." msgstr "Renvoie ``True`` si la tâche est *achevée*." #: library/asyncio-task.rst:1027 msgid "" "A Task is *done* when the wrapped coroutine either returned a value, raised " "an exception, or the Task was cancelled." msgstr "" "Une tâche est dite *achevée* quand la coroutine encapsulée a soit renvoyé " "une valeur, soit levé une exception, ou que la tâche a été annulée." #: library/asyncio-task.rst:1032 msgid "Return the result of the Task." msgstr "Renvoie le résultat de la tâche." #: library/asyncio-task.rst:1034 msgid "" "If the Task is *done*, the result of the wrapped coroutine is returned (or " "if the coroutine raised an exception, that exception is re-raised.)" msgstr "" "Si la tâche est *achevée*, le résultat de la coroutine encapsulée est " "renvoyé (sinon, dans le cas où la coroutine a levé une exception, cette " "exception est de nouveau levée)." #: library/asyncio-task.rst:1052 msgid "" "If the Task has been *cancelled*, this method raises a :exc:`CancelledError` " "exception." msgstr "" "Si la tâche a été *annulée*, cette méthode lève une exception :exc:" "`CancelledError`." #: library/asyncio-task.rst:1041 msgid "" "If the Task's result isn't yet available, this method raises a :exc:" "`InvalidStateError` exception." msgstr "" "Si le résultat de la tâche n'est pas encore disponible, cette méthode lève " "une exception :exc:`InvalidStateError`." #: library/asyncio-task.rst:1046 msgid "Return the exception of the Task." msgstr "Renvoie l'exception de la tâche." #: library/asyncio-task.rst:1048 msgid "" "If the wrapped coroutine raised an exception that exception is returned. If " "the wrapped coroutine returned normally this method returns ``None``." msgstr "" "Si la coroutine encapsulée lève une exception, cette exception est renvoyée. " "Si la coroutine s'est exécutée normalement, cette méthode renvoie ``None``." #: library/asyncio-task.rst:1055 msgid "" "If the Task isn't *done* yet, this method raises an :exc:`InvalidStateError` " "exception." msgstr "" "Si la tâche n'est pas encore *achevée*, cette méthode lève une exception :" "exc:`InvalidStateError`." #: library/asyncio-task.rst:1060 msgid "Add a callback to be run when the Task is *done*." msgstr "" "Ajoute une fonction de rappel qui sera exécutée quand la tâche sera " "*achevée*." #: library/asyncio-task.rst:1071 msgid "This method should only be used in low-level callback-based code." msgstr "" "Cette méthode ne doit être utilisée que dans du code basé sur les fonctions " "de rappel de bas-niveau." #: library/asyncio-task.rst:1064 msgid "" "See the documentation of :meth:`Future.add_done_callback` for more details." msgstr "" "Se référer à la documentation de :meth:`Future.add_done_callback` pour plus " "de détails." #: library/asyncio-task.rst:1069 msgid "Remove *callback* from the callbacks list." msgstr "Retire *callback* de la liste de fonctions de rappel." #: library/asyncio-task.rst:1073 msgid "" "See the documentation of :meth:`Future.remove_done_callback` for more " "details." msgstr "" "Se référer à la documentation de :meth:`Future.remove_done_callback` pour " "plus de détails." #: library/asyncio-task.rst:1078 msgid "Return the list of stack frames for this Task." msgstr "Renvoie une liste représentant la pile d'appels de la tâche." #: library/asyncio-task.rst:1080 msgid "" "If the wrapped coroutine is not done, this returns the stack where it is " "suspended. If the coroutine has completed successfully or was cancelled, " "this returns an empty list. If the coroutine was terminated by an exception, " "this returns the list of traceback frames." msgstr "" "Si la coroutine encapsulée n'est pas terminée, cette fonction renvoie la " "pile d'appels à partir de l'endroit où celle-ci est interrompue. Si la " "coroutine s'est terminée normalement ou a été annulée, cette fonction " "renvoie une liste vide. Si la coroutine a été terminée par une exception, " "ceci renvoie la pile d'erreurs." #: library/asyncio-task.rst:1086 msgid "The frames are always ordered from oldest to newest." msgstr "La pile est toujours affichée de l'appelant à l'appelé." #: library/asyncio-task.rst:1088 msgid "Only one stack frame is returned for a suspended coroutine." msgstr "Une seule ligne est renvoyée si la coroutine est suspendue." #: library/asyncio-task.rst:1090 msgid "" "The optional *limit* argument sets the maximum number of frames to return; " "by default all available frames are returned. The ordering of the returned " "list differs depending on whether a stack or a traceback is returned: the " "newest frames of a stack are returned, but the oldest frames of a traceback " "are returned. (This matches the behavior of the traceback module.)" msgstr "" "L'argument facultatif *limit* définit le nombre maximal d'appels à " "renvoyer ; par défaut, tous sont renvoyés. L'ordre de la liste diffère selon " "la nature de celle-ci : les appels les plus récents d'une pile d'appels sont " "renvoyés, si la pile est une pile d'erreurs, ce sont les appels les plus " "anciens qui le sont (dans un souci de cohérence avec le module *traceback*)." #: library/asyncio-task.rst:1099 msgid "Print the stack or traceback for this Task." msgstr "Affiche la pile d'appels ou d'erreurs de la tâche." #: library/asyncio-task.rst:1101 msgid "" "This produces output similar to that of the traceback module for the frames " "retrieved by :meth:`get_stack`." msgstr "" "Le format de sortie des appels produits par :meth:`get_stack` est similaire " "à celui du module *traceback*." #: library/asyncio-task.rst:1104 msgid "The *limit* argument is passed to :meth:`get_stack` directly." msgstr "Le paramètre *limit* est directement passé à :meth:`get_stack`." #: library/asyncio-task.rst:1106 msgid "" "The *file* argument is an I/O stream to which the output is written; by " "default output is written to :data:`sys.stdout`." msgstr "" "Le paramètre *file* est un flux d'entrées-sorties sur lequel le résultat est " "écrit ; par défaut, :data:`sys.stdout`." #: library/asyncio-task.rst:1111 msgid "Return the coroutine object wrapped by the :class:`Task`." msgstr "Renvoie l’objet *coroutine* encapsulé par la :class:`Task`." #: library/asyncio-task.rst:1117 msgid "Return the name of the Task." msgstr "Renvoie le nom de la tâche." #: library/asyncio-task.rst:1119 msgid "" "If no name has been explicitly assigned to the Task, the default asyncio " "Task implementation generates a default name during instantiation." msgstr "" "Si aucun nom n’a été explicitement assigné à la tâche, l’implémentation par " "défaut d’une *Task* *asyncio* génère un nom par défaut durant " "l’instanciation." #: library/asyncio-task.rst:1127 msgid "Set the name of the Task." msgstr "Définit le nom de la tâche." #: library/asyncio-task.rst:1129 msgid "" "The *value* argument can be any object, which is then converted to a string." msgstr "" "L’argument *value* peut être n’importe quel objet qui sera ensuite converti " "en chaine de caractères." #: library/asyncio-task.rst:1132 msgid "" "In the default Task implementation, the name will be visible in the :func:" "`repr` output of a task object." msgstr "" "Dans l’implémentation par défaut de *Task*, le nom sera visible dans le " "résultat de :func:`repr` d’un objet *Task*." #: library/asyncio-task.rst:1139 msgid "Request the Task to be cancelled." msgstr "Demande l'annulation d'une tâche." #: library/asyncio-task.rst:1141 msgid "" "This arranges for a :exc:`CancelledError` exception to be thrown into the " "wrapped coroutine on the next cycle of the event loop." msgstr "" "Provisionne la levée de l'exception :exc:`CancelledError` dans la coroutine " "encapsulée. L'exception sera levée au prochain cycle de la boucle " "d'exécution." #: library/asyncio-task.rst:1144 msgid "" "The coroutine then has a chance to clean up or even deny the request by " "suppressing the exception with a :keyword:`try` ... ... ``except " "CancelledError`` ... :keyword:`finally` block. Therefore, unlike :meth:" "`Future.cancel`, :meth:`Task.cancel` does not guarantee that the Task will " "be cancelled, although suppressing cancellation completely is not common and " "is actively discouraged. Should the coroutine nevertheless decide to " "suppress the cancellation, it needs to call :meth:`Task.uncancel` in " "addition to catching the exception." msgstr "" "La coroutine peut alors faire le ménage ou même ignorer la requête en " "supprimant l'exception à l'aide d'un bloc :keyword:`try` … … ``except " "CancelledError`` … :keyword:`finally`. Par conséquent, contrairement à :meth:" "`Future.cancel`, :meth:`Task.cancel` ne garantit pas que la tâche sera " "annulée, bien qu'ignorer totalement une annulation ne soit ni une pratique " "courante, ni encouragé. Si la coroutine décide néanmoins de supprimer " "l'annulation, elle doit appeler :meth:`Task.uncancel` en plus d'intercepter " "l'exception." # suit un : #: library/asyncio-task.rst:1154 msgid "Added the *msg* parameter." msgstr "ajout du paramètre *msg*." # suit un : #: library/asyncio-task.rst:1157 msgid "The ``msg`` parameter is propagated from cancelled task to its awaiter." msgstr "" "le paramètre ``msg`` est propagé de la tâche annulée vers celle qui l'attend." #: library/asyncio-task.rst:1162 msgid "" "The following example illustrates how coroutines can intercept the " "cancellation request::" msgstr "" "L'exemple ci-dessous illustre comment une coroutine peut intercepter une " "requête d'annulation ::" #: library/asyncio-task.rst:1201 msgid "Return ``True`` if the Task is *cancelled*." msgstr "Renvoie ``True`` si la tâche est *annulée*." #: library/asyncio-task.rst:1203 msgid "" "The Task is *cancelled* when the cancellation was requested with :meth:" "`cancel` and the wrapped coroutine propagated the :exc:`CancelledError` " "exception thrown into it." msgstr "" "La tâche est *annulée* quand l'annulation a été demandée avec :meth:`cancel` " "et la coroutine encapsulée a propagé l'exception :exc:`CancelledError` qui a " "été levée en son sein." #: library/asyncio-task.rst:1209 msgid "Decrement the count of cancellation requests to this Task." msgstr "Décrémente le nombre de demandes d'annulation pour cette tâche." #: library/asyncio-task.rst:1211 msgid "Returns the remaining number of cancellation requests." msgstr "Renvoie le nombre restant de demandes d'annulation." #: library/asyncio-task.rst:1213 msgid "" "Note that once execution of a cancelled task completed, further calls to :" "meth:`uncancel` are ineffective." msgstr "" "Notez qu'une fois l'exécution d'une tâche annulée terminée, les appels " "ultérieurs à :meth:`uncancel` ne font rien." #: library/asyncio-task.rst:1218 msgid "" "This method is used by asyncio's internals and isn't expected to be used by " "end-user code. In particular, if a Task gets successfully uncancelled, this " "allows for elements of structured concurrency like :ref:`taskgroups` and :" "func:`asyncio.timeout` to continue running, isolating cancellation to the " "respective structured block. For example::" msgstr "" "Cette méthode est utilisée par les composants internes d'*asyncio* et elle " "ne devrait pas être utilisée par le code de l'utilisateur final. En " "particulier, si une tâche est annulée avec succès, cela permet aux " "structures permettant le multi-fils tels que :ref:`taskgroups` et :func:" "`asyncio.timeout` de continuer à s'exécuter, isolant l'annulation au bloc " "concerné. Par exemple ::" #: library/asyncio-task.rst:1236 msgid "" "While the block with ``make_request()`` and ``make_another_request()`` might " "get cancelled due to the timeout, ``unrelated_code()`` should continue " "running even in case of the timeout. This is implemented with :meth:" "`uncancel`. :class:`TaskGroup` context managers use :func:`uncancel` in a " "similar fashion." msgstr "" "Alors que le bloc avec ``make_request()`` et ``make_another_request()`` peut " "être annulé en raison du délai d'attente, ``unrelated_code()`` devrait " "continuer à s'exécuter même en cas d'atteinte du délai maximal. Ceci est " "implémenté avec :meth:`uncancel`. Les gestionnaires de contexte :class:" "`TaskGroup` utilisent :func:`uncancel` de la même manière." #: library/asyncio-task.rst:1242 msgid "" "If end-user code is, for some reason, suppresing cancellation by catching :" "exc:`CancelledError`, it needs to call this method to remove the " "cancellation state." msgstr "" "Si, pour une raison quelconque, le code de l'utilisateur final supprime " "l'annulation en interceptant :exc:`CancelledError`, il doit appeler cette " "méthode pour supprimer l'état d'annulation." #: library/asyncio-task.rst:1248 msgid "" "Return the number of pending cancellation requests to this Task, i.e., the " "number of calls to :meth:`cancel` less the number of :meth:`uncancel` calls." msgstr "" "Renvoie le nombre de demandes d'annulation en attente à cette tâche, c'est-à-" "dire le nombre d'appels à :meth:`cancel` moins le nombre d'appels à :meth:" "`uncancel`." #: library/asyncio-task.rst:1252 msgid "" "Note that if this number is greater than zero but the Task is still " "executing, :meth:`cancelled` will still return ``False``. This is because " "this number can be lowered by calling :meth:`uncancel`, which can lead to " "the task not being cancelled after all if the cancellation requests go down " "to zero." msgstr "" "Notez que si ce nombre est supérieur à zéro mais que la tâche est toujours " "en cours d'exécution, :meth:`cancelled` renvoie toujours ``False``. En " "effet, ce nombre peut être réduit en appelant :meth:`uncancel`, ce qui peut " "empêcher en fin de compte la tâche d'être annulée si les demandes " "d'annulation tombent à zéro." #: library/asyncio-task.rst:1258 msgid "" "This method is used by asyncio's internals and isn't expected to be used by " "end-user code. See :meth:`uncancel` for more details." msgstr "" "Cette méthode est utilisée par les composants internes d'*asyncio* et ne " "devrait pas être utilisée par le code de l'utilisateur final. Voir :meth:" "`uncancel` pour plus de détails." #~ msgid "" #~ "Tasks support the :mod:`contextvars` module. When a Task is created it " #~ "copies the current context and later runs its coroutine in the copied " #~ "context." #~ msgstr "" #~ "*Task* implémente le module :mod:`contextvars`. Lors de sa création, une " #~ "tâche effectue une copie du contexte actuel et exécute ses coroutines " #~ "dans cette copie." #~ msgid "Running an asyncio Program" #~ msgstr "Exécution d'un programme *asyncio*" #~ msgid "Execute the :term:`coroutine` *coro* and return the result." #~ msgstr "Exécute la :term:`coroutine` *coro* et renvoie le résultat." #, fuzzy #~ msgid "" #~ "This function runs the passed coroutine, taking care of managing the " #~ "asyncio event loop, *finalizing asynchronous generators*, and closing the " #~ "threadpool." #~ msgstr "" #~ "Cette fonction exécute la coroutine passée en argument. Elle gère la " #~ "boucle d'événements *asyncio* et *finalise les générateurs asynchrones*." #~ msgid "" #~ "This function cannot be called when another asyncio event loop is running " #~ "in the same thread." #~ msgstr "" #~ "Cette fonction ne peut pas être appelée si une autre boucle d'événement " #~ "*asyncio* s'exécute dans le même fil d'exécution." #~ msgid "If *debug* is ``True``, the event loop will be run in debug mode." #~ msgstr "" #~ "Si *debug* vaut ``True``, la boucle d'événement s'exécute en mode de " #~ "débogage." #~ msgid "" #~ "This function always creates a new event loop and closes it at the end. " #~ "It should be used as a main entry point for asyncio programs, and should " #~ "ideally only be called once." #~ msgstr "" #~ "Cette fonction crée toujours une nouvelle boucle d'événement et la clôt à " #~ "la fin. Elle doit être utilisée comme point d'entrée principal des " #~ "programmes *asyncio* et ne doit être idéalement appelée qu'une seule fois." #~ msgid "" #~ "The source code for ``asyncio.run()`` can be found in :source:`Lib/" #~ "asyncio/runners.py`." #~ msgstr "" #~ "Le code source pour ``asyncio.run()`` est disponible dans :source:`Lib/" #~ "asyncio/runners.py`." #~ msgid "" #~ "This function has been **added in Python 3.7**. Prior to Python 3.7, the " #~ "low-level :func:`asyncio.ensure_future` function can be used instead::" #~ msgstr "" #~ "Cette fonction a été **ajoutée dans Python 3.7**. Pour les versions " #~ "antérieures à la 3.7, la fonction de bas-niveau :func:`asyncio." #~ "ensure_future` peut-être utilisée ::" #~ msgid "" #~ "asyncio also supports legacy :ref:`generator-based " #~ "` coroutines." #~ msgstr "" #~ "*asyncio* implémente également les coroutines :ref:`basées sur des " #~ "générateurs ` ; celles-ci sont obsolètes." #~ msgid "" #~ "If any awaitable in *aws* is a coroutine, it is automatically scheduled " #~ "as a Task. Passing coroutines objects to ``wait()`` directly is " #~ "deprecated as it leads to :ref:`confusing behavior " #~ "`." #~ msgstr "" #~ "Si un *awaitable* de *aws* est une coroutine, celle-ci est " #~ "automatiquement planifiée comme une tâche. Passer directement des objets " #~ "coroutines à ``wait()`` est obsolète, car ceci conduisait :ref:`à un " #~ "comportement portant à confusion `." #~ msgid "" #~ "``wait()`` schedules coroutines as Tasks automatically and later returns " #~ "those implicitly created Task objects in ``(done, pending)`` sets. " #~ "Therefore the following code won't work as expected::" #~ msgstr "" #~ "``wait()`` planifie automatiquement les coroutines comme des tâches et " #~ "renvoie les objets *Task* ainsi créés dans les ensembles ``(done, " #~ "pending)``. Le code suivant ne fonctionne donc pas comme voulu ::" #~ msgid "Here is how the above snippet can be fixed::" #~ msgstr "Voici comment corriger le morceau de code ci-dessus ::" #~ msgid "Generator-based Coroutines" #~ msgstr "Coroutines basées sur des générateurs" #~ msgid "" #~ "Support for generator-based coroutines is **deprecated** and is scheduled " #~ "for removal in Python 3.10." #~ msgstr "" #~ "Les coroutines basées sur des générateurs sont **obsolètes** et il est " #~ "prévu de les supprimer en Python 3.10." #~ msgid "" #~ "Generator-based coroutines predate async/await syntax. They are Python " #~ "generators that use ``yield from`` expressions to await on Futures and " #~ "other coroutines." #~ msgstr "" #~ "Les coroutines basées sur des générateurs sont antérieures à la syntaxe " #~ "*async* / *await*. Il existe des générateurs *Python* qui utilisent les " #~ "expressions ``yield from`` pour attendre des *futurs* et autres " #~ "coroutines." #~ msgid "" #~ "Generator-based coroutines should be decorated with :func:`@asyncio." #~ "coroutine `, although this is not enforced." #~ msgstr "" #~ "Les coroutines basées sur des générateurs doivent être décorées avec :" #~ "func:`@asyncio.coroutine `, même si ce n'est pas " #~ "vérifié par l'interpréteur." #~ msgid "Decorator to mark generator-based coroutines." #~ msgstr "Décorateur pour coroutines basées sur des générateurs." #~ msgid "" #~ "This decorator enables legacy generator-based coroutines to be compatible " #~ "with async/await code::" #~ msgstr "" #~ "Ce décorateur rend compatibles les coroutines basées sur des générateurs " #~ "avec le code *async* / *await* ::" #~ msgid "" #~ "This decorator should not be used for :keyword:`async def` coroutines." #~ msgstr "" #~ "Ce décorateur ne doit pas être utilisé avec des coroutines :keyword:" #~ "`async def`." # pas de majuscule car suit un deux-points #~ msgid "Use :keyword:`async def` instead." #~ msgstr "utilisez :keyword:`async def` à la place." #~ msgid "" #~ "This method is different from :func:`inspect.iscoroutine` because it " #~ "returns ``True`` for generator-based coroutines." #~ msgstr "" #~ "Cette méthode est différente de :func:`inspect.iscoroutine` car elle " #~ "renvoie ``True`` pour des coroutines basées sur des générateurs." #~ msgid "" #~ "Return ``True`` if *func* is a :ref:`coroutine function `." #~ msgstr "" #~ "Renvoie ``True`` si *func* est une :ref:`fonction coroutine `." #~ msgid "" #~ "This method is different from :func:`inspect.iscoroutinefunction` because " #~ "it returns ``True`` for generator-based coroutine functions decorated " #~ "with :func:`@coroutine `." #~ msgstr "" #~ "Cette méthode est différente de :func:`inspect.iscoroutinefunction` car " #~ "elle renvoie ``True`` pour des coroutines basées sur des générateurs, " #~ "décorées avec :func:`@coroutine `."