# 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-01-15 22:33+0100\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME \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" #: library/concurrent.futures.rst:2 #, fuzzy msgid ":mod:`concurrent.futures` --- Launching parallel tasks" msgstr ":mod:`concurrent.futures` -- Lancer des tâches en parallèle" #: library/concurrent.futures.rst:9 msgid "" "**Source code:** :source:`Lib/concurrent/futures/thread.py` and :source:`Lib/" "concurrent/futures/process.py`" msgstr "" #: library/concurrent.futures.rst:14 msgid "" "The :mod:`concurrent.futures` module provides a high-level interface for " "asynchronously executing callables." msgstr "" #: 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 "" #: includes/wasm-notavail.rst:None msgid ":ref:`Availability `: not Emscripten, not WASI." msgstr "" #: includes/wasm-notavail.rst:5 msgid "" "This module does not work or is not available on WebAssembly platforms " "``wasm32-emscripten`` and ``wasm32-wasi``. See :ref:`wasm-availability` for " "more information." msgstr "" #: library/concurrent.futures.rst:25 msgid "Executor Objects" msgstr "" #: library/concurrent.futures.rst:29 msgid "" "An abstract class that provides methods to execute calls asynchronously. It " "should not be used directly, but through its concrete subclasses." msgstr "" #: library/concurrent.futures.rst:34 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 "" #: library/concurrent.futures.rst:44 msgid "Similar to :func:`map(func, *iterables) ` except:" msgstr "" #: library/concurrent.futures.rst:46 msgid "the *iterables* are collected immediately rather than lazily;" msgstr "" #: library/concurrent.futures.rst:48 msgid "" "*func* is executed asynchronously and several calls to *func* may be made " "concurrently." msgstr "" #: library/concurrent.futures.rst:51 msgid "" "The returned iterator raises a :exc:`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 "" #: library/concurrent.futures.rst:57 msgid "" "If a *func* call raises an exception, then that exception will be raised " "when its value is retrieved from the iterator." msgstr "" #: library/concurrent.futures.rst:60 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 "" #: library/concurrent.futures.rst:68 msgid "Added the *chunksize* argument." msgstr "" #: library/concurrent.futures.rst:73 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 "" #: library/concurrent.futures.rst:78 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 "" #: library/concurrent.futures.rst:86 msgid "" "If *cancel_futures* is ``True``, this method will cancel all pending futures " "that the executor has not started running. Any futures that are completed or " "running won't be cancelled, regardless of the value of *cancel_futures*." msgstr "" #: library/concurrent.futures.rst:91 msgid "" "If both *cancel_futures* and *wait* are ``True``, all futures that the " "executor has started running will be completed prior to this method " "returning. The remaining futures are cancelled." msgstr "" #: library/concurrent.futures.rst:95 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 "" #: library/concurrent.futures.rst:107 msgid "Added *cancel_futures*." msgstr "" #: library/concurrent.futures.rst:112 msgid "ThreadPoolExecutor" msgstr "ThreadPoolExecutor" #: library/concurrent.futures.rst:114 msgid "" ":class:`ThreadPoolExecutor` is an :class:`Executor` subclass that uses a " "pool of threads to execute calls asynchronously." msgstr "" #: library/concurrent.futures.rst:117 msgid "" "Deadlocks can occur when the callable associated with a :class:`Future` " "waits on the results of another :class:`Future`. For example::" msgstr "" #: library/concurrent.futures.rst:136 msgid "And::" msgstr "Et ::" #: library/concurrent.futures.rst:150 msgid "" "An :class:`Executor` subclass that uses a pool of at most *max_workers* " "threads to execute calls asynchronously." msgstr "" #: library/concurrent.futures.rst:153 msgid "" "All threads enqueued to ``ThreadPoolExecutor`` will be joined before the " "interpreter can exit. Note that the exit handler which does this is executed " "*before* any exit handlers added using ``atexit``. This means exceptions in " "the main thread must be caught and handled in order to signal threads to " "exit gracefully. For this reason, it is recommended that " "``ThreadPoolExecutor`` not be used for long-running tasks." msgstr "" #: library/concurrent.futures.rst:160 msgid "" "*initializer* is an optional callable that is called at the start of each " "worker thread; *initargs* is a tuple of arguments passed to the " "initializer. Should *initializer* raise an exception, all currently pending " "jobs will raise a :exc:`~concurrent.futures.thread.BrokenThreadPool`, as " "well as any attempt to submit more jobs to the pool." msgstr "" #: library/concurrent.futures.rst:166 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 "" #: library/concurrent.futures.rst:174 msgid "" "The *thread_name_prefix* argument was added to allow users to control the :" "class:`threading.Thread` names for worker threads created by the pool for " "easier debugging." msgstr "" #: library/concurrent.futures.rst:179 library/concurrent.futures.rst:281 msgid "Added the *initializer* and *initargs* arguments." msgstr "" #: library/concurrent.futures.rst:182 msgid "" "Default value of *max_workers* is changed to ``min(32, os.cpu_count() + " "4)``. This default value preserves at least 5 workers for I/O bound tasks. " "It utilizes at most 32 CPU cores for CPU bound tasks which release the GIL. " "And it avoids using very large resources implicitly on many-core machines." msgstr "" #: library/concurrent.futures.rst:188 msgid "" "ThreadPoolExecutor now reuses idle worker threads before starting " "*max_workers* worker threads too." msgstr "" #: library/concurrent.futures.rst:195 msgid "ThreadPoolExecutor Example" msgstr "" #: library/concurrent.futures.rst:227 msgid "ProcessPoolExecutor" msgstr "ProcessPoolExecutor" #: library/concurrent.futures.rst:229 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 "" #: library/concurrent.futures.rst:236 msgid "" "The ``__main__`` module must be importable by worker subprocesses. This " "means that :class:`ProcessPoolExecutor` will not work in the interactive " "interpreter." msgstr "" #: library/concurrent.futures.rst:239 msgid "" "Calling :class:`Executor` or :class:`Future` methods from a callable " "submitted to a :class:`ProcessPoolExecutor` will result in deadlock." msgstr "" #: library/concurrent.futures.rst:244 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 less than or equal to ``0``, then a :exc:`ValueError` will " "be raised. On Windows, *max_workers* must be less than or equal to ``61``. " "If it is not then :exc:`ValueError` will be raised. If *max_workers* is " "``None``, then the default chosen will be at most ``61``, even if more " "processors are available. *mp_context* can be a multiprocessing context or " "None. It will be used to launch the workers. If *mp_context* is ``None`` or " "not given, the default multiprocessing context is used." msgstr "" #: library/concurrent.futures.rst:257 msgid "" "*initializer* is an optional callable that is called at the start of each " "worker process; *initargs* is a tuple of arguments passed to the " "initializer. Should *initializer* raise an exception, all currently pending " "jobs will raise a :exc:`~concurrent.futures.process.BrokenProcessPool`, as " "well as any attempt to submit more jobs to the pool." msgstr "" #: library/concurrent.futures.rst:263 msgid "" "*max_tasks_per_child* is an optional argument that specifies the maximum " "number of tasks a single process can execute before it will exit and be " "replaced with a fresh worker process. By default *max_tasks_per_child* is " "``None`` which means worker processes will live as long as the pool. When a " "max is specified, the \"spawn\" multiprocessing start method will be used by " "default in absence of a *mp_context* parameter. This feature is incompatible " "with the \"fork\" start method." msgstr "" #: library/concurrent.futures.rst:271 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 "" #: library/concurrent.futures.rst:277 msgid "" "The *mp_context* argument was added to allow users to control the " "start_method for worker processes created by the pool." msgstr "" #: library/concurrent.futures.rst:283 msgid "" "The *max_tasks_per_child* argument was added to allow users to control the " "lifetime of workers in the pool." msgstr "" #: library/concurrent.futures.rst:291 msgid "ProcessPoolExecutor Example" msgstr "" #: library/concurrent.futures.rst:329 msgid "Future Objects" msgstr "" #: library/concurrent.futures.rst:331 msgid "" "The :class:`Future` class encapsulates the asynchronous execution of a " "callable. :class:`Future` instances are created by :meth:`Executor.submit`." msgstr "" #: library/concurrent.futures.rst:336 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 "" #: library/concurrent.futures.rst:342 msgid "" "Attempt to cancel the call. If the call is currently being executed or " "finished running and cannot be cancelled then the method will return " "``False``, otherwise the call will be cancelled and the method will return " "``True``." msgstr "" #: library/concurrent.futures.rst:349 msgid "Return ``True`` if the call was successfully cancelled." msgstr "" #: library/concurrent.futures.rst:353 msgid "" "Return ``True`` if the call is currently being executed and cannot be " "cancelled." msgstr "" #: library/concurrent.futures.rst:358 msgid "" "Return ``True`` if the call was successfully cancelled or finished running." msgstr "" #: library/concurrent.futures.rst:363 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:`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 "" #: library/concurrent.futures.rst:370 library/concurrent.futures.rst:384 msgid "" "If the future is cancelled before completing then :exc:`.CancelledError` " "will be raised." msgstr "" #: library/concurrent.futures.rst:373 msgid "" "If the call raised an exception, this method will raise the same exception." msgstr "" #: library/concurrent.futures.rst:377 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:`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 "" #: library/concurrent.futures.rst:387 msgid "If the call completed without raising, ``None`` is returned." msgstr "" #: library/concurrent.futures.rst:391 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 "" #: library/concurrent.futures.rst:395 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 "" #: library/concurrent.futures.rst:401 msgid "" "If the future has already completed or been cancelled, *fn* will be called " "immediately." msgstr "" #: library/concurrent.futures.rst:404 msgid "" "The following :class:`Future` methods are meant for use in unit tests and :" "class:`Executor` implementations." msgstr "" #: library/concurrent.futures.rst:409 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 "" #: library/concurrent.futures.rst:413 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 "" #: library/concurrent.futures.rst:418 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 "" #: library/concurrent.futures.rst:422 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 "" #: library/concurrent.futures.rst:428 msgid "" "Sets the result of the work associated with the :class:`Future` to *result*." msgstr "" #: library/concurrent.futures.rst:431 library/concurrent.futures.rst:444 msgid "" "This method should only be used by :class:`Executor` implementations and " "unit tests." msgstr "" #: library/concurrent.futures.rst:434 library/concurrent.futures.rst:447 msgid "" "This method raises :exc:`concurrent.futures.InvalidStateError` if the :class:" "`Future` is already done." msgstr "" #: library/concurrent.futures.rst:441 msgid "" "Sets the result of the work associated with the :class:`Future` to the :" "class:`Exception` *exception*." msgstr "" #: library/concurrent.futures.rst:453 msgid "Module Functions" msgstr "" #: library/concurrent.futures.rst:457 msgid "" "Wait for the :class:`Future` instances (possibly created by different :class:" "`Executor` instances) given by *fs* to complete. Duplicate futures given to " "*fs* are removed and will be returned only once. Returns a named 2-tuple of " "sets. The first set, named ``done``, contains the futures that completed " "(finished or cancelled futures) before the wait completed. The second set, " "named ``not_done``, contains the futures that did not complete (pending or " "running futures)." msgstr "" #: library/concurrent.futures.rst:465 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 "" #: library/concurrent.futures.rst:469 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/concurrent.futures.rst:475 msgid "Constant" msgstr "Constante" #: library/concurrent.futures.rst:475 msgid "Description" msgstr "Description" #: library/concurrent.futures.rst:477 msgid ":const:`FIRST_COMPLETED`" msgstr ":const:`FIRST_COMPLETED`" #: library/concurrent.futures.rst:477 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/concurrent.futures.rst:480 msgid ":const:`FIRST_EXCEPTION`" msgstr ":const:`FIRST_EXCEPTION`" #: library/concurrent.futures.rst:480 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/concurrent.futures.rst:486 msgid ":const:`ALL_COMPLETED`" msgstr ":const:`ALL_COMPLETED`" #: library/concurrent.futures.rst:486 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/concurrent.futures.rst:492 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 cancelled futures). 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:`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 "" #: library/concurrent.futures.rst:506 msgid ":pep:`3148` -- futures - execute computations asynchronously" msgstr "" #: library/concurrent.futures.rst:506 msgid "" "The proposal which described this feature for inclusion in the Python " "standard library." msgstr "" #: library/concurrent.futures.rst:511 msgid "Exception classes" msgstr "" #: library/concurrent.futures.rst:517 msgid "Raised when a future is cancelled." msgstr "" #: library/concurrent.futures.rst:521 msgid "" "A deprecated alias of :exc:`TimeoutError`, raised when a future operation " "exceeds the given timeout." msgstr "" #: library/concurrent.futures.rst:526 msgid "This class was made an alias of :exc:`TimeoutError`." msgstr "" #: library/concurrent.futures.rst:531 msgid "" "Derived from :exc:`RuntimeError`, this exception class is raised when an " "executor is broken for some reason, and cannot be used to submit or execute " "new tasks." msgstr "" #: library/concurrent.futures.rst:539 msgid "" "Raised when an operation is performed on a future that is not allowed in the " "current state." msgstr "" #: library/concurrent.futures.rst:548 msgid "" "Derived from :exc:`~concurrent.futures.BrokenExecutor`, this exception class " "is raised when one of the workers of a :class:`ThreadPoolExecutor` has " "failed initializing." msgstr "" #: library/concurrent.futures.rst:558 msgid "" "Derived from :exc:`~concurrent.futures.BrokenExecutor` (formerly :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 ""