# Copyright (C) 2001-2018, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-06-28 15:29+0200\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

#: ../Doc/library/asyncio-task.rst:4
msgid "Tasks and coroutines"
msgstr "Tâches et coroutines"

#: ../Doc/library/asyncio-task.rst:6
msgid "**Source code:** :source:`Lib/asyncio/tasks.py`"
msgstr ""

#: ../Doc/library/asyncio-task.rst:8
msgid "**Source code:** :source:`Lib/asyncio/coroutines.py`"
msgstr ""

#: ../Doc/library/asyncio-task.rst:13
msgid "Coroutines"
msgstr "Coroutines"

#: ../Doc/library/asyncio-task.rst:15
msgid ""
"Coroutines used with :mod:`asyncio` may be implemented using the :keyword:"
"`async def` statement, or by using :term:`generators <generator>`. The :"
"keyword:`async def` type of coroutine was added in Python 3.5, and is "
"recommended if there is no need to support older Python versions."
msgstr ""

#: ../Doc/library/asyncio-task.rst:20
msgid ""
"Generator-based coroutines should be decorated with :func:`@asyncio."
"coroutine <asyncio.coroutine>`, although this is not strictly enforced. The "
"decorator enables compatibility with :keyword:`async def` coroutines, and "
"also serves as documentation.  Generator-based coroutines use the ``yield "
"from`` syntax introduced in :pep:`380`, instead of the original ``yield`` "
"syntax."
msgstr ""

#: ../Doc/library/asyncio-task.rst:27
msgid ""
"The word \"coroutine\", like the word \"generator\", is used for two "
"different (though related) concepts:"
msgstr ""

#: ../Doc/library/asyncio-task.rst:30
msgid ""
"The function that defines a coroutine (a function definition using :keyword:"
"`async def` or decorated with ``@asyncio.coroutine``).  If disambiguation is "
"needed we will call this a *coroutine function* (:func:`iscoroutinefunction` "
"returns ``True``)."
msgstr ""

#: ../Doc/library/asyncio-task.rst:36
msgid ""
"The object obtained by calling a coroutine function.  This object represents "
"a computation or an I/O operation (usually a combination) that will complete "
"eventually.  If disambiguation is needed we will call it a *coroutine "
"object* (:func:`iscoroutine` returns ``True``)."
msgstr ""

#: ../Doc/library/asyncio-task.rst:41
msgid "Things a coroutine can do:"
msgstr "Les choses que les coroutines peuvent faire :"

#: ../Doc/library/asyncio-task.rst:43
msgid ""
"``result = await future`` or ``result = yield from future`` -- suspends the "
"coroutine until the future is done, then returns the future's result, or "
"raises an exception, which will be propagated.  (If the future is cancelled, "
"it will raise a ``CancelledError`` exception.)  Note that tasks are futures, "
"and everything said about futures also applies to tasks."
msgstr ""

#: ../Doc/library/asyncio-task.rst:50
msgid ""
"``result = await coroutine`` or ``result = yield from coroutine`` -- wait "
"for another coroutine to produce a result (or raise an exception, which will "
"be propagated). The ``coroutine`` expression must be a *call* to another "
"coroutine."
msgstr ""

#: ../Doc/library/asyncio-task.rst:55
msgid ""
"``return expression`` -- produce a result to the coroutine that is waiting "
"for this one using :keyword:`await` or ``yield from``."
msgstr ""

#: ../Doc/library/asyncio-task.rst:58
msgid ""
"``raise exception`` -- raise an exception in the coroutine that is waiting "
"for this one using :keyword:`await` or ``yield from``."
msgstr ""

#: ../Doc/library/asyncio-task.rst:61
msgid ""
"Calling a coroutine does not start its code running -- the coroutine object "
"returned by the call doesn't do anything until you schedule its execution.  "
"There are two basic ways to start it running: call ``await coroutine`` or "
"``yield from coroutine`` from another coroutine (assuming the other "
"coroutine is already running!), or schedule its execution using the :func:"
"`ensure_future` function or the :meth:`AbstractEventLoop.create_task` method."
msgstr ""

#: ../Doc/library/asyncio-task.rst:70
msgid "Coroutines (and tasks) can only run when the event loop is running."
msgstr ""

#: ../Doc/library/asyncio-task.rst:74
msgid ""
"Decorator to mark generator-based coroutines.  This enables the generator "
"use :keyword:`!yield from` to call :keyword:`async def` coroutines, and also "
"enables the generator to be called by :keyword:`async def` coroutines, for "
"instance using an :keyword:`await` expression."
msgstr ""

#: ../Doc/library/asyncio-task.rst:80
msgid ""
"There is no need to decorate :keyword:`async def` coroutines themselves."
msgstr ""

#: ../Doc/library/asyncio-task.rst:82
msgid ""
"If the generator is not yielded from before it is destroyed, an error "
"message is logged. See :ref:`Detect coroutines never scheduled <asyncio-"
"coroutine-not-scheduled>`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:88
msgid ""
"In this documentation, some methods are documented as coroutines, even if "
"they are plain Python functions returning a :class:`Future`. This is "
"intentional to have a freedom of tweaking the implementation of these "
"functions in the future. If such a function is needed to be used in a "
"callback-style code, wrap its result with :func:`ensure_future`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:97
msgid ""
"This function runs the passed coroutine, taking care of managing the asyncio "
"event loop and finalizing asynchronous generators."
msgstr ""

#: ../Doc/library/asyncio-task.rst:101
msgid ""
"This function cannot be called when another asyncio event loop is running in "
"the same thread."
msgstr ""

#: ../Doc/library/asyncio-task.rst:104
msgid "If debug is True, the event loop will be run in debug mode."
msgstr ""

#: ../Doc/library/asyncio-task.rst:106
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 ""

#: ../Doc/library/asyncio-task.rst:110
msgid ""
"**Important:** this has been been added to asyncio in Python 3.7 on a :term:"
"`provisional basis <provisional api>`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:118
msgid "Example: Hello World coroutine"
msgstr "Exemple : Coroutine \"Hello World\""

#: ../Doc/library/asyncio-task.rst:120
msgid "Example of coroutine displaying ``\"Hello World\"``::"
msgstr ""

#: ../Doc/library/asyncio-task.rst:131
msgid ""
"The :ref:`Hello World with call_soon() <asyncio-hello-world-callback>` "
"example uses the :meth:`AbstractEventLoop.call_soon` method to schedule a "
"callback."
msgstr ""

#: ../Doc/library/asyncio-task.rst:139
msgid "Example: Coroutine displaying the current date"
msgstr "Exemple : Coroutine affichant la date actuelle"

#: ../Doc/library/asyncio-task.rst:141
msgid ""
"Example of coroutine displaying the current date every second during 5 "
"seconds using the :meth:`sleep` function::"
msgstr ""

#: ../Doc/library/asyncio-task.rst:160
msgid ""
"The :ref:`display the current date with call_later() <asyncio-date-"
"callback>` example uses a callback with the :meth:`AbstractEventLoop."
"call_later` method."
msgstr ""

#: ../Doc/library/asyncio-task.rst:166
msgid "Example: Chain coroutines"
msgstr "Exemple : Chaîner des coroutines"

#: ../Doc/library/asyncio-task.rst:168
msgid "Example chaining coroutines::"
msgstr ""

#: ../Doc/library/asyncio-task.rst:185
msgid ""
"``compute()`` is chained to ``print_sum()``: ``print_sum()`` coroutine waits "
"until ``compute()`` is completed before returning its result."
msgstr ""

#: ../Doc/library/asyncio-task.rst:188
msgid "Sequence diagram of the example:"
msgstr ""

#: ../Doc/library/asyncio-task.rst:193
msgid ""
"The \"Task\" is created by the :meth:`AbstractEventLoop.run_until_complete` "
"method when it gets a coroutine object instead of a task."
msgstr ""

#: ../Doc/library/asyncio-task.rst:196
msgid ""
"The diagram shows the control flow, it does not describe exactly how things "
"work internally. For example, the sleep coroutine creates an internal future "
"which uses :meth:`AbstractEventLoop.call_later` to wake up the task in 1 "
"second."
msgstr ""

#: ../Doc/library/asyncio-task.rst:202
msgid "InvalidStateError"
msgstr "InvalidStateError"

#: ../Doc/library/asyncio-task.rst:206
msgid "The operation is not allowed in this state."
msgstr "L'opération n'est pas autorisée dans cet état."

#: ../Doc/library/asyncio-task.rst:210
msgid "TimeoutError"
msgstr "TimeoutError"

#: ../Doc/library/asyncio-task.rst:214
msgid "The operation exceeded the given deadline."
msgstr "L'opération a dépassé la deadline donnée."

#: ../Doc/library/asyncio-task.rst:218
msgid ""
"This exception is different from the builtin :exc:`TimeoutError` exception!"
msgstr ""

#: ../Doc/library/asyncio-task.rst:222
msgid "Future"
msgstr ""

#: ../Doc/library/asyncio-task.rst:226
msgid ""
"This class is *almost* compatible with :class:`concurrent.futures.Future`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:228
msgid "Differences:"
msgstr "Différences :"

#: ../Doc/library/asyncio-task.rst:230
msgid ""
":meth:`result` and :meth:`exception` do not take a timeout argument and "
"raise an exception when the future isn't done yet."
msgstr ""

#: ../Doc/library/asyncio-task.rst:233
msgid ""
"Callbacks registered with :meth:`add_done_callback` are always called via "
"the event loop's :meth:`~AbstractEventLoop.call_soon`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:236
msgid ""
"This class is not compatible with the :func:`~concurrent.futures.wait` and :"
"func:`~concurrent.futures.as_completed` functions in the :mod:`concurrent."
"futures` package."
msgstr ""

#: ../Doc/library/asyncio-task.rst:240 ../Doc/library/asyncio-task.rst:436
msgid "This class is :ref:`not thread safe <asyncio-multithreading>`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:244
msgid "Cancel the future and schedule callbacks."
msgstr ""

#: ../Doc/library/asyncio-task.rst:246
msgid ""
"If the future is already done or cancelled, return ``False``. Otherwise, "
"change the future's state to cancelled, schedule the callbacks and return "
"``True``."
msgstr ""

#: ../Doc/library/asyncio-task.rst:252
msgid "Return ``True`` if the future was cancelled."
msgstr ""

#: ../Doc/library/asyncio-task.rst:256
msgid "Return ``True`` if the future is done."
msgstr ""

#: ../Doc/library/asyncio-task.rst:258
msgid ""
"Done means either that a result / exception are available, or that the "
"future was cancelled."
msgstr ""

#: ../Doc/library/asyncio-task.rst:263
msgid "Return the result this future represents."
msgstr ""

#: ../Doc/library/asyncio-task.rst:265
msgid ""
"If the future has been cancelled, raises :exc:`CancelledError`. If the "
"future's result isn't yet available, raises :exc:`InvalidStateError`. If the "
"future is done and has an exception set, this exception is raised."
msgstr ""

#: ../Doc/library/asyncio-task.rst:271
msgid "Return the exception that was set on this future."
msgstr ""

#: ../Doc/library/asyncio-task.rst:273
msgid ""
"The exception (or ``None`` if no exception was set) is returned only if the "
"future is done. If the future has been cancelled, raises :exc:"
"`CancelledError`. If the future isn't done yet, raises :exc:"
"`InvalidStateError`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:280
msgid "Add a callback to be run when the future becomes done."
msgstr ""

#: ../Doc/library/asyncio-task.rst:282
msgid ""
"The *callback* is called with a single argument - the future object. If the "
"future is already done when this is called, the callback is scheduled with :"
"meth:`~AbstractEventLoop.call_soon`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:286
msgid ""
"An optional keyword-only *context* argument allows specifying a custom :"
"class:`contextvars.Context` for the *callback* to run in.  The current "
"context is used when no *context* is provided."
msgstr ""

#: ../Doc/library/asyncio-task.rst:290
msgid ""
":ref:`Use functools.partial to pass parameters to the callback <asyncio-pass-"
"keywords>`. For example, ``fut.add_done_callback(functools.partial(print, "
"\"Future:\", flush=True))`` will call ``print(\"Future:\", fut, "
"flush=True)``."
msgstr ""

#: ../Doc/library/asyncio-task.rst:295
msgid ""
"The *context* keyword-only parameter was added. See :pep:`567` for more "
"details."
msgstr ""

#: ../Doc/library/asyncio-task.rst:301
msgid "Remove all instances of a callback from the \"call when done\" list."
msgstr ""

#: ../Doc/library/asyncio-task.rst:303
msgid "Returns the number of callbacks removed."
msgstr "Donne le nombre de fonctions de rappel supprimées."

#: ../Doc/library/asyncio-task.rst:307
msgid "Mark the future done and set its result."
msgstr "Marque le futur comme terminé et définit son résultat."

#: ../Doc/library/asyncio-task.rst:309 ../Doc/library/asyncio-task.rst:316
msgid ""
"If the future is already done when this method is called, raises :exc:"
"`InvalidStateError`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:314
msgid "Mark the future done and set an exception."
msgstr "Marque le futur comme terminé et définit une exception."

#: ../Doc/library/asyncio-task.rst:321
msgid "Return the event loop the future object is bound to."
msgstr ""

#: ../Doc/library/asyncio-task.rst:327
msgid "Example: Future with run_until_complete()"
msgstr "Exemple : Futur avec ``run_until_complete()``"

#: ../Doc/library/asyncio-task.rst:329
msgid ""
"Example combining a :class:`Future` and a :ref:`coroutine function "
"<coroutine>`::"
msgstr ""

#: ../Doc/library/asyncio-task.rst:345
msgid ""
"The coroutine function is responsible for the computation (which takes 1 "
"second) and it stores the result into the future. The :meth:"
"`~AbstractEventLoop.run_until_complete` method waits for the completion of "
"the future."
msgstr ""

#: ../Doc/library/asyncio-task.rst:351
msgid ""
"The :meth:`~AbstractEventLoop.run_until_complete` method uses internally "
"the :meth:`~Future.add_done_callback` method to be notified when the future "
"is done."
msgstr ""

#: ../Doc/library/asyncio-task.rst:357
msgid "Example: Future with run_forever()"
msgstr "Exemple : Futur avec ``run_forever()``"

#: ../Doc/library/asyncio-task.rst:359
msgid ""
"The previous example can be written differently using the :meth:`Future."
"add_done_callback` method to describe explicitly the control flow::"
msgstr ""

#: ../Doc/library/asyncio-task.rst:382
msgid ""
"In this example, the future is used to link ``slow_operation()`` to "
"``got_result()``: when ``slow_operation()`` is done, ``got_result()`` is "
"called with the result."
msgstr ""

#: ../Doc/library/asyncio-task.rst:388
msgid "Task"
msgstr ""

#: ../Doc/library/asyncio-task.rst:392
msgid ""
"Wrap a :ref:`coroutine <coroutine>` *coro* into a task and schedule its "
"execution.  Return the task object."
msgstr ""

#: ../Doc/library/asyncio-task.rst:395
msgid ""
"The task is executed in :func:`get_running_loop` context, :exc:"
"`RuntimeError` is raised if there is no running loop in current thread."
msgstr ""

#: ../Doc/library/asyncio-task.rst:403
msgid ""
"A unit for concurrent running of :ref:`coroutines <coroutine>`, subclass of :"
"class:`Future`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:406
msgid ""
"A task is responsible for executing a coroutine object in an event loop.  If "
"the wrapped coroutine yields from a future, the task suspends the execution "
"of the wrapped coroutine and waits for the completion of the future. When "
"the future is done, the execution of the wrapped coroutine restarts with the "
"result or the exception of the future."
msgstr ""

#: ../Doc/library/asyncio-task.rst:412
msgid ""
"Event loops use cooperative scheduling: an event loop only runs one task at "
"a time. Other tasks may run in parallel if other event loops are running in "
"different threads. While a task waits for the completion of a future, the "
"event loop executes a new task."
msgstr ""

#: ../Doc/library/asyncio-task.rst:417
msgid ""
"The cancellation of a task is different from the cancellation of a future. "
"Calling :meth:`cancel` will throw a :exc:`~concurrent.futures."
"CancelledError` to the wrapped coroutine. :meth:`~Future.cancelled` only "
"returns ``True`` if the wrapped coroutine did not catch the :exc:"
"`~concurrent.futures.CancelledError` exception, or raised a :exc:"
"`~concurrent.futures.CancelledError` exception."
msgstr ""

#: ../Doc/library/asyncio-task.rst:425
msgid ""
"If a pending task is destroyed, the execution of its wrapped :ref:`coroutine "
"<coroutine>` did not complete. It is probably a bug and a warning is logged: "
"see :ref:`Pending task destroyed <asyncio-pending-task-destroyed>`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:429
msgid ""
"Don't directly create :class:`Task` instances: use the :func:`create_task` "
"function or the :meth:`AbstractEventLoop.create_task` method."
msgstr ""

#: ../Doc/library/asyncio-task.rst:432
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.  See :pep:`567` for more details."
msgstr ""

#: ../Doc/library/asyncio-task.rst:438
msgid "Added support for the :mod:`contextvars` module."
msgstr ""

#: ../Doc/library/asyncio-task.rst:443
msgid "Return a set of all tasks for an event loop."
msgstr "Donne l'ensemble des tâches d'une boucle d'évènements."

#: ../Doc/library/asyncio-task.rst:445
msgid ""
"By default all tasks for the current event loop are returned. If *loop* is "
"``None``, :func:`get_event_loop` function is used to get the current loop."
msgstr ""

#: ../Doc/library/asyncio-task.rst:451
msgid "Return the currently running task in an event loop or ``None``."
msgstr ""

#: ../Doc/library/asyncio-task.rst:453
msgid "By default the current task for the current event loop is returned."
msgstr ""

#: ../Doc/library/asyncio-task.rst:455
msgid "``None`` is returned when called not in the context of a :class:`Task`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:459
msgid "Request that this task cancel itself."
msgstr "Demande à ce qu'une tâche s'annule elle même."

#: ../Doc/library/asyncio-task.rst:461
msgid ""
"This arranges for a :exc:`~concurrent.futures.CancelledError` to be thrown "
"into the wrapped coroutine on the next cycle through the event loop. The "
"coroutine then has a chance to clean up or even deny the request using try/"
"except/finally."
msgstr ""

#: ../Doc/library/asyncio-task.rst:466
msgid ""
"Unlike :meth:`Future.cancel`, this does not guarantee that the task will be "
"cancelled: the exception might be caught and acted upon, delaying "
"cancellation of the task or preventing cancellation completely. The task may "
"also return a value or raise a different exception."
msgstr ""

#: ../Doc/library/asyncio-task.rst:471
msgid ""
"Immediately after this method is called, :meth:`~Future.cancelled` will not "
"return ``True`` (unless the task was already cancelled). A task will be "
"marked as cancelled when the wrapped coroutine terminates with a :exc:"
"`~concurrent.futures.CancelledError` exception (even if :meth:`cancel` was "
"not called)."
msgstr ""

#: ../Doc/library/asyncio-task.rst:479
msgid "Return the list of stack frames for this task's coroutine."
msgstr ""

#: ../Doc/library/asyncio-task.rst:481
msgid ""
"If the 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 ""

#: ../Doc/library/asyncio-task.rst:487
msgid "The frames are always ordered from oldest to newest."
msgstr ""

#: ../Doc/library/asyncio-task.rst:489
msgid ""
"The optional limit gives the maximum number of frames to return; by default "
"all available frames are returned.  Its meaning 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 ""

#: ../Doc/library/asyncio-task.rst:495
msgid ""
"For reasons beyond our control, only one stack frame is returned for a "
"suspended coroutine."
msgstr ""

#: ../Doc/library/asyncio-task.rst:500
msgid "Print the stack or traceback for this task's coroutine."
msgstr ""

#: ../Doc/library/asyncio-task.rst:502
msgid ""
"This produces output similar to that of the traceback module, for the frames "
"retrieved by get_stack().  The limit argument is passed to get_stack().  The "
"file argument is an I/O stream to which the output is written; by default "
"output is written to sys.stderr."
msgstr ""

#: ../Doc/library/asyncio-task.rst:509
msgid "Example: Parallel execution of tasks"
msgstr "Exemple : Exécution parallèle de tâches"

#: ../Doc/library/asyncio-task.rst:511
msgid "Example executing 3 tasks (A, B, C) in parallel::"
msgstr "Exemple d'exécution de trois tâches (A, B, C) en parallèle : ::"

#: ../Doc/library/asyncio-task.rst:531
msgid "Output::"
msgstr "Sortie ::"

#: ../Doc/library/asyncio-task.rst:543
msgid ""
"A task is automatically scheduled for execution when it is created. The "
"event loop stops when all tasks are done."
msgstr ""

#: ../Doc/library/asyncio-task.rst:548
msgid "Task functions"
msgstr ""

#: ../Doc/library/asyncio-task.rst:552
msgid ""
"In the functions below, the optional *loop* argument allows explicitly "
"setting the event loop object used by the underlying task or coroutine.  If "
"it's not provided, the default event loop is used."
msgstr ""

#: ../Doc/library/asyncio-task.rst:559
msgid ""
"Return the current running :class:`Task` instance or ``None``, if no task is "
"running."
msgstr ""

#: ../Doc/library/asyncio-task.rst:562
msgid ""
"If *loop* is ``None`` :func:`get_running_loop` is used to get the current "
"loop."
msgstr ""

#: ../Doc/library/asyncio-task.rst:570
#, fuzzy
msgid "Return a set of :class:`Task` objects created for the loop."
msgstr "Donne l'ensemble des tâches d'une boucle d'évènements."

#: ../Doc/library/asyncio-task.rst:572
msgid ""
"If *loop* is ``None``, :func:`get_running_loop` is used for getting current "
"loop (contrary to the deprecated :meth:`Task.all_tasks` method that uses :"
"func:`get_event_loop`.)"
msgstr ""

#: ../Doc/library/asyncio-task.rst:581
msgid ""
"Return an iterator whose values, when waited for, are :class:`Future` "
"instances."
msgstr ""

#: ../Doc/library/asyncio-task.rst:584
msgid ""
"Raises :exc:`asyncio.TimeoutError` if the timeout occurs before all Futures "
"are done."
msgstr ""

#: ../Doc/library/asyncio-task.rst:587
msgid "Example::"
msgstr "Exemple ::"

#: ../Doc/library/asyncio-task.rst:595
msgid "The futures ``f`` are not necessarily members of fs."
msgstr ""

#: ../Doc/library/asyncio-task.rst:599
msgid ""
"Schedule the execution of a :ref:`coroutine object <coroutine>`: wrap it in "
"a future. Return a :class:`Task` object."
msgstr ""

#: ../Doc/library/asyncio-task.rst:602
msgid "If the argument is a :class:`Future`, it is returned directly."
msgstr ""

#: ../Doc/library/asyncio-task.rst:606
msgid "The function accepts any :term:`awaitable` object."
msgstr "La fonction accepte n'importe quel objet :term:`awaitable`."

#: ../Doc/library/asyncio-task.rst:611
msgid ""
":func:`create_task` (added in Python 3.7) is the preferable way for spawning "
"new tasks."
msgstr ""

#: ../Doc/library/asyncio-task.rst:616
msgid ""
"The :func:`create_task` function and :meth:`AbstractEventLoop.create_task` "
"method."
msgstr ""

#: ../Doc/library/asyncio-task.rst:621
msgid ""
"Wrap a :class:`concurrent.futures.Future` object in a :class:`Future` object."
msgstr ""

#: ../Doc/library/asyncio-task.rst:626
msgid ""
"Return a future aggregating results from the given coroutine objects or "
"futures."
msgstr ""

#: ../Doc/library/asyncio-task.rst:629
msgid ""
"All futures must share the same event loop.  If all the tasks are done "
"successfully, the returned future's result is the list of results (in the "
"order of the original sequence, not necessarily the order of results "
"arrival).  If *return_exceptions* is true, exceptions in the tasks are "
"treated the same as successful results, and gathered in the result list; "
"otherwise, the first raised exception will be immediately propagated to the "
"returned future."
msgstr ""

#: ../Doc/library/asyncio-task.rst:637
msgid ""
"Cancellation: if the outer Future is cancelled, all children (that have not "
"completed yet) are also cancelled.  If any child is cancelled, this is "
"treated as if it raised :exc:`~concurrent.futures.CancelledError` -- the "
"outer Future is *not* cancelled in this case.  (This is to prevent the "
"cancellation of one child to cause other children to be cancelled.)"
msgstr ""

#: ../Doc/library/asyncio-task.rst:643
msgid ""
"If the *gather* itself is cancelled, the cancellation is propagated "
"regardless of *return_exceptions*."
msgstr ""

#: ../Doc/library/asyncio-task.rst:649
msgid ""
"Return ``True`` if *obj* is a :ref:`coroutine object <coroutine>`, which may "
"be based on a generator or an :keyword:`async def` coroutine."
msgstr ""

#: ../Doc/library/asyncio-task.rst:654
msgid ""
"Return ``True`` if *func* is determined to be a :ref:`coroutine function "
"<coroutine>`, which may be a decorated generator function or an :keyword:"
"`async def` function."
msgstr ""

#: ../Doc/library/asyncio-task.rst:660
msgid "Submit a :ref:`coroutine object <coroutine>` to a given event loop."
msgstr ""

#: ../Doc/library/asyncio-task.rst:662
msgid "Return a :class:`concurrent.futures.Future` to access the result."
msgstr ""

#: ../Doc/library/asyncio-task.rst:664
msgid ""
"This function is meant to be called from a different thread than the one "
"where the event loop is running. Usage::"
msgstr ""

#: ../Doc/library/asyncio-task.rst:674
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 ""

#: ../Doc/library/asyncio-task.rst:687
msgid ""
"See the :ref:`concurrency and multithreading <asyncio-multithreading>` "
"section of the documentation."
msgstr ""

#: ../Doc/library/asyncio-task.rst:692
msgid ""
"Unlike other functions from the module, :func:`run_coroutine_threadsafe` "
"requires the *loop* argument to be passed explicitly."
msgstr ""

#: ../Doc/library/asyncio-task.rst:700
msgid ""
"Create a :ref:`coroutine <coroutine>` that completes after a given time (in "
"seconds).  If *result* is provided, it is produced to the caller when the "
"coroutine completes."
msgstr ""

#: ../Doc/library/asyncio-task.rst:704
msgid ""
"The resolution of the sleep depends on the :ref:`granularity of the event "
"loop <asyncio-delayed-calls>`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:707 ../Doc/library/asyncio-task.rst:774
msgid "This function is a :ref:`coroutine <coroutine>`."
msgstr "Cette fonction est une :ref:`coroutine <coroutine>`."

#: ../Doc/library/asyncio-task.rst:711
msgid "Wait for a future, shielding it from cancellation."
msgstr "Attends un future, en le protégeant des annulations."

#: ../Doc/library/asyncio-task.rst:713
msgid "The statement::"
msgstr "L'instruction : ::"

#: ../Doc/library/asyncio-task.rst:717
msgid "is exactly equivalent to the statement::"
msgstr "est exactement équivalente à l'instruction : ::"

#: ../Doc/library/asyncio-task.rst:721
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.  But its caller is still "
"cancelled, so the yield-from expression still raises :exc:`~concurrent."
"futures.CancelledError`.  Note: If ``something()`` is cancelled by other "
"means this will still cancel ``shield()``."
msgstr ""

#: ../Doc/library/asyncio-task.rst:728
msgid ""
"If you want to completely ignore cancellation (not recommended) you can "
"combine ``shield()`` with a try/except clause, as follows::"
msgstr ""

#: ../Doc/library/asyncio-task.rst:740
msgid ""
"Wait for the Futures and coroutine objects given by the sequence *futures* "
"to complete.  Coroutines will be wrapped in Tasks. Returns two sets of :"
"class:`Future`: (done, pending)."
msgstr ""

#: ../Doc/library/asyncio-task.rst:744
msgid "The sequence *futures* must not be empty."
msgstr ""

#: ../Doc/library/asyncio-task.rst:746
msgid ""
"*timeout* can be used to control the maximum number of seconds to wait "
"before returning.  *timeout* can be an int or float.  If *timeout* is not "
"specified or ``None``, there is no limit to the wait time."
msgstr ""

#: ../Doc/library/asyncio-task.rst:750
msgid ""
"*return_when* indicates when this function should return.  It must be one of "
"the following constants of the :mod:`concurrent.futures` module:"
msgstr ""

#: ../Doc/library/asyncio-task.rst:756
msgid "Constant"
msgstr "Constante"

#: ../Doc/library/asyncio-task.rst:756
msgid "Description"
msgstr "Description"

#: ../Doc/library/asyncio-task.rst:758
msgid ":const:`FIRST_COMPLETED`"
msgstr ":const:`FIRST_COMPLETED`"

#: ../Doc/library/asyncio-task.rst:758
msgid "The function will return when any future finishes or is cancelled."
msgstr ""

#: ../Doc/library/asyncio-task.rst:761
msgid ":const:`FIRST_EXCEPTION`"
msgstr ":const:`FIRST_EXCEPTION`"

#: ../Doc/library/asyncio-task.rst:761
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 ""

#: ../Doc/library/asyncio-task.rst:767
msgid ":const:`ALL_COMPLETED`"
msgstr ":const:`ALL_COMPLETED`"

#: ../Doc/library/asyncio-task.rst:767
msgid "The function will return when all futures finish or are cancelled."
msgstr ""

#: ../Doc/library/asyncio-task.rst:771
msgid ""
"Unlike :func:`~asyncio.wait_for`, ``wait()`` will not cancel the futures "
"when a timeout occurs."
msgstr ""

#: ../Doc/library/asyncio-task.rst:776
msgid "Usage::"
msgstr ""

#: ../Doc/library/asyncio-task.rst:782
msgid ""
"This does not raise :exc:`asyncio.TimeoutError`! Futures that aren't done "
"when the timeout occurs are returned in the second set."
msgstr ""

#: ../Doc/library/asyncio-task.rst:788
msgid ""
"Wait for the single :class:`Future` or :ref:`coroutine object <coroutine>` "
"to complete with timeout. If *timeout* is ``None``, block until the future "
"completes."
msgstr ""

#: ../Doc/library/asyncio-task.rst:792
msgid "Coroutine will be wrapped in :class:`Task`."
msgstr ""

#: ../Doc/library/asyncio-task.rst:794
msgid ""
"Returns result of the Future or coroutine.  When a timeout occurs, it "
"cancels the task and raises :exc:`asyncio.TimeoutError`. To avoid the task "
"cancellation, wrap it in :func:`shield`.  The function will wait until the "
"future is actually cancelled, so the total wait time may exceed the "
"*timeout*."
msgstr ""

#: ../Doc/library/asyncio-task.rst:800
msgid "If the wait is cancelled, the future *fut* is also cancelled."
msgstr ""

#: ../Doc/library/asyncio-task.rst:802
msgid "This function is a :ref:`coroutine <coroutine>`, usage::"
msgstr "Cette fonction est une :ref:`coroutine <coroutine>`, utilisation : ::"

#: ../Doc/library/asyncio-task.rst:806
msgid "If the wait is cancelled, the future *fut* is now also cancelled."
msgstr ""

#: ../Doc/library/asyncio-task.rst:809
msgid ""
"When *fut* is cancelled due to a timeout, ``wait_for`` now waits for *fut* "
"to be cancelled.  Previously, it raised :exc:`~asyncio.TimeoutError` "
"immediately."
msgstr ""

#~ msgid "A deprecated alias to :func:`ensure_future`."
#~ msgstr "Un alias obsolète de :func:`ensure_future`."

#~ msgid "The same coroutine implemented using a generator::"
#~ msgstr "La même coroutine implémentée en utilisant un générateur : ::"
