python-docs-fr/library/concurrent.futures.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2016, 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-01-04 15:51+0100\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/concurrent.futures.rst:2
msgid ":mod:`concurrent.futures` --- Launching parallel tasks"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:9
msgid ""
"**Source code:** :source:`Lib/concurrent/futures/thread.py` and :source:`Lib/"
"concurrent/futures/process.py`"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:14
msgid ""
"The :mod:`concurrent.futures` module provides a high-level interface for "
"asynchronously executing callables."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:17
msgid ""
"The asynchronous execution can be performed with threads, using :class:"
"`ThreadPoolExecutor`, or separate processes, using :class:"
"`ProcessPoolExecutor`.  Both implement the same interface, which is defined "
"by the abstract :class:`Executor` class."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:24
msgid "Executor Objects"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:28
msgid ""
"An abstract class that provides methods to execute calls asynchronously.  It "
"should not be used directly, but through its concrete subclasses."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:33
msgid ""
"Schedules the callable, *fn*, to be executed as ``fn(*args **kwargs)`` and "
"returns a :class:`Future` object representing the execution of the "
"callable. ::"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:43
msgid "Similar to :func:`map(func, *iterables) <map>` except:"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:45
msgid "the *iterables* are collected immediately rather than lazily;"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:47
msgid ""
"*func* is executed asynchronously and several calls to *func* may be made "
"concurrently."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:50
msgid ""
"The returned iterator raises a :exc:`concurrent.futures.TimeoutError` if :"
"meth:`~iterator.__next__` is called and the result isn't available after "
"*timeout* seconds from the original call to :meth:`Executor.map`. *timeout* "
"can be an int or a float.  If *timeout* is not specified or ``None``, there "
"is no limit to the wait time."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:56
msgid ""
"If a *func* call raises an exception, then that exception will be raised "
"when its value is retrieved from the iterator."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:59
msgid ""
"When using :class:`ProcessPoolExecutor`, this method chops *iterables* into "
"a number of chunks which it submits to the pool as separate tasks.  The "
"(approximate) size of these chunks can be specified by setting *chunksize* "
"to a positive integer.  For very long iterables, using a large value for "
"*chunksize* can significantly improve performance compared to the default "
"size of 1.  With :class:`ThreadPoolExecutor`, *chunksize* has no effect."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:67
msgid "Added the *chunksize* argument."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:72
msgid ""
"Signal the executor that it should free any resources that it is using when "
"the currently pending futures are done executing.  Calls to :meth:`Executor."
"submit` and :meth:`Executor.map` made after shutdown will raise :exc:"
"`RuntimeError`."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:77
msgid ""
"If *wait* is ``True`` then this method will not return until all the pending "
"futures are done executing and the resources associated with the executor "
"have been freed.  If *wait* is ``False`` then this method will return "
"immediately and the resources associated with the executor will be freed "
"when all pending futures are done executing.  Regardless of the value of "
"*wait*, the entire Python program will not exit until all pending futures "
"are done executing."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:85
msgid ""
"You can avoid having to call this method explicitly if you use the :keyword:"
"`with` statement, which will shutdown the :class:`Executor` (waiting as if :"
"meth:`Executor.shutdown` were called with *wait* set to ``True``)::"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:99
msgid "ThreadPoolExecutor"
msgstr "ThreadPoolExecutor"

#: ../Doc/library/concurrent.futures.rst:101
msgid ""
":class:`ThreadPoolExecutor` is an :class:`Executor` subclass that uses a "
"pool of threads to execute calls asynchronously."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:104
msgid ""
"Deadlocks can occur when the callable associated with a :class:`Future` "
"waits on the results of another :class:`Future`.  For example::"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:123
msgid "And::"
msgstr "Et ::"

#: ../Doc/library/concurrent.futures.rst:137
msgid ""
"An :class:`Executor` subclass that uses a pool of at most *max_workers* "
"threads to execute calls asynchronously."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:140
msgid ""
"If *max_workers* is ``None`` or not given, it will default to the number of "
"processors on the machine, multiplied by ``5``, assuming that :class:"
"`ThreadPoolExecutor` is often used to overlap I/O instead of CPU work and "
"the number of workers should be higher than the number of workers for :class:"
"`ProcessPoolExecutor`."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:148
msgid ""
"The *thread_name_prefix* argument was added to allow users to control the "
"threading.Thread names for worker threads created by the pool for easier "
"debugging."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:156
msgid "ThreadPoolExecutor Example"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:188
msgid "ProcessPoolExecutor"
msgstr "ProcessPoolExecutor"

#: ../Doc/library/concurrent.futures.rst:190
msgid ""
"The :class:`ProcessPoolExecutor` class is an :class:`Executor` subclass that "
"uses a pool of processes to execute calls asynchronously. :class:"
"`ProcessPoolExecutor` uses the :mod:`multiprocessing` module, which allows "
"it to side-step the :term:`Global Interpreter Lock` but also means that only "
"picklable objects can be executed and returned."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:196
msgid ""
"The ``__main__`` module must be importable by worker subprocesses. This "
"means that :class:`ProcessPoolExecutor` will not work in the interactive "
"interpreter."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:199
msgid ""
"Calling :class:`Executor` or :class:`Future` methods from a callable "
"submitted to a :class:`ProcessPoolExecutor` will result in deadlock."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:204
msgid ""
"An :class:`Executor` subclass that executes calls asynchronously using a "
"pool of at most *max_workers* processes.  If *max_workers* is ``None`` or "
"not given, it will default to the number of processors on the machine. If "
"*max_workers* is lower or equal to ``0``, then a :exc:`ValueError` will be "
"raised."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:210
msgid ""
"When one of the worker processes terminates abruptly, a :exc:"
"`BrokenProcessPool` error is now raised.  Previously, behaviour was "
"undefined but operations on the executor or its futures would often freeze "
"or deadlock."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:220
msgid "ProcessPoolExecutor Example"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:254
msgid "Future Objects"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:256
msgid ""
"The :class:`Future` class encapsulates the asynchronous execution of a "
"callable. :class:`Future` instances are created by :meth:`Executor.submit`."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:261
msgid ""
"Encapsulates the asynchronous execution of a callable.  :class:`Future` "
"instances are created by :meth:`Executor.submit` and should not be created "
"directly except for testing."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:267
msgid ""
"Attempt to cancel the call.  If the call is currently being executed and "
"cannot be cancelled then the method will return ``False``, otherwise the "
"call will be cancelled and the method will return ``True``."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:273
msgid "Return ``True`` if the call was successfully cancelled."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:277
msgid ""
"Return ``True`` if the call is currently being executed and cannot be "
"cancelled."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:282
msgid ""
"Return ``True`` if the call was successfully cancelled or finished running."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:287
msgid ""
"Return the value returned by the call. If the call hasn't yet completed then "
"this method will wait up to *timeout* seconds.  If the call hasn't completed "
"in *timeout* seconds, then a :exc:`concurrent.futures.TimeoutError` will be "
"raised. *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/concurrent.futures.rst:294
#: ../Doc/library/concurrent.futures.rst:308
msgid ""
"If the future is cancelled before completing then :exc:`.CancelledError` "
"will be raised."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:297
msgid "If the call raised, this method will raise the same exception."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:301
msgid ""
"Return the exception raised by the call.  If the call hasn't yet completed "
"then this method will wait up to *timeout* seconds.  If the call hasn't "
"completed in *timeout* seconds, then a :exc:`concurrent.futures."
"TimeoutError` will be raised.  *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/concurrent.futures.rst:311
msgid "If the call completed without raising, ``None`` is returned."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:315
msgid ""
"Attaches the callable *fn* to the future.  *fn* will be called, with the "
"future as its only argument, when the future is cancelled or finishes "
"running."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:319
msgid ""
"Added callables are called in the order that they were added and are always "
"called in a thread belonging to the process that added them.  If the "
"callable raises an :exc:`Exception` subclass, it will be logged and "
"ignored.  If the callable raises a :exc:`BaseException` subclass, the "
"behavior is undefined."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:325
msgid ""
"If the future has already completed or been cancelled, *fn* will be called "
"immediately."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:328
msgid ""
"The following :class:`Future` methods are meant for use in unit tests and :"
"class:`Executor` implementations."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:333
msgid ""
"This method should only be called by :class:`Executor` implementations "
"before executing the work associated with the :class:`Future` and by unit "
"tests."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:337
msgid ""
"If the method returns ``False`` then the :class:`Future` was cancelled, i."
"e. :meth:`Future.cancel` was called and returned `True`.  Any threads "
"waiting on the :class:`Future` completing (i.e. through :func:`as_completed` "
"or :func:`wait`) will be woken up."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:342
msgid ""
"If the method returns ``True`` then the :class:`Future` was not cancelled "
"and has been put in the running state, i.e. calls to :meth:`Future.running` "
"will return `True`."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:346
msgid ""
"This method can only be called once and cannot be called after :meth:`Future."
"set_result` or :meth:`Future.set_exception` have been called."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:352
msgid ""
"Sets the result of the work associated with the :class:`Future` to *result*."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:355
#: ../Doc/library/concurrent.futures.rst:363
msgid ""
"This method should only be used by :class:`Executor` implementations and "
"unit tests."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:360
msgid ""
"Sets the result of the work associated with the :class:`Future` to the :"
"class:`Exception` *exception*."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:368
msgid "Module Functions"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:372
msgid ""
"Wait for the :class:`Future` instances (possibly created by different :class:"
"`Executor` instances) given by *fs* to complete.  Returns a named 2-tuple of "
"sets.  The first set, named ``done``, contains the futures that completed "
"(finished or were cancelled) before the wait completed.  The second set, "
"named ``not_done``, contains uncompleted futures."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:378
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/concurrent.futures.rst:382
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 :"

#: ../Doc/library/concurrent.futures.rst:388
msgid "Constant"
msgstr "Constante"

#: ../Doc/library/concurrent.futures.rst:388
msgid "Description"
msgstr "Description"

#: ../Doc/library/concurrent.futures.rst:390
msgid ":const:`FIRST_COMPLETED`"
msgstr ":const:`FIRST_COMPLETED`"

#: ../Doc/library/concurrent.futures.rst:390
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é."

#: ../Doc/library/concurrent.futures.rst:393
msgid ":const:`FIRST_EXCEPTION`"
msgstr ":const:`FIRST_EXCEPTION`"

#: ../Doc/library/concurrent.futures.rst:393
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`."

#: ../Doc/library/concurrent.futures.rst:399
msgid ":const:`ALL_COMPLETED`"
msgstr ":const:`ALL_COMPLETED`"

#: ../Doc/library/concurrent.futures.rst:399
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."

#: ../Doc/library/concurrent.futures.rst:405
msgid ""
"Returns an iterator over the :class:`Future` instances (possibly created by "
"different :class:`Executor` instances) given by *fs* that yields futures as "
"they complete (finished or were cancelled). Any futures given by *fs* that "
"are duplicated will be returned once. Any futures that completed before :"
"func:`as_completed` is called will be yielded first.  The returned iterator "
"raises a :exc:`concurrent.futures.TimeoutError` if :meth:`~iterator."
"__next__` is called and the result isn't available after *timeout* seconds "
"from the original call to :func:`as_completed`.  *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/concurrent.futures.rst:419
msgid ":pep:`3148` -- futures - execute computations asynchronously"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:419
msgid ""
"The proposal which described this feature for inclusion in the Python "
"standard library."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:424
msgid "Exception classes"
msgstr ""

#: ../Doc/library/concurrent.futures.rst:430
msgid "Raised when a future is cancelled."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:434
msgid "Raised when a future operation exceeds the given timeout."
msgstr ""

#: ../Doc/library/concurrent.futures.rst:440
msgid ""
"Derived from :exc:`RuntimeError`, this exception class is raised when one of "
"the workers of a :class:`ProcessPoolExecutor` has terminated in a non-clean "
"fashion (for example, if it was killed from the outside)."
msgstr ""