python-docs-fa/library/concurrent.futures.po at update-CI · python/python-docs-fa

940 lines (819 loc) · 33.9 KB
# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# Translators:
# Alireza Shabani (Revisto) <theRevisto@gmail.com>, 2025
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-07-25 12:59+0330\n"
"PO-Revision-Date: 2021-06-28 00:57+0000\n"
"Last-Translator: Rafael Fontenelle <rffontenelle@gmail.com>, 2025\n"
"Language-Team: Persian (https://app.transifex.com/python-doc/teams/5390/"
"Language: fa\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
#: ../../library/concurrent.futures.rst:2
msgid ":mod:`!concurrent.futures` --- Launching parallel tasks"
#: ../../library/concurrent.futures.rst:9
"**Source code:** :source:`Lib/concurrent/futures/thread.py`, :source:`Lib/"
"concurrent/futures/process.py`, and :source:`Lib/concurrent/futures/"
"interpreter.py`"
#: ../../library/concurrent.futures.rst:15
"The :mod:`!concurrent.futures` module provides a high-level interface for "
"asynchronously executing callables."
#: ../../library/concurrent.futures.rst:18
"The asynchronous execution can be performed with threads, "
"using :class:`ThreadPoolExecutor` or :class:`InterpreterPoolExecutor`, or "
"separate processes, using :class:`ProcessPoolExecutor`. Each implements the "
"same interface, which is defined by the abstract :class:`Executor` class."
#: ../../library/concurrent.futures.rst:24
":class:`concurrent.futures.Future` must not be confused "
"with :class:`asyncio.Future`, which is designed for use with :mod:`asyncio` "
"tasks and coroutines. See the :doc:`asyncio's Future <asyncio-future>` "
"documentation for a detailed comparison of the two."
#: ../../includes/wasm-notavail.rst:3
msgid "Availability"
#: ../../includes/wasm-notavail.rst:5
"This module does not work or is not available on WebAssembly. See :ref:`wasm-"
"availability` for more information."
#: ../../library/concurrent.futures.rst:32
msgid "Executor Objects"
#: ../../library/concurrent.futures.rst:36
"An abstract class that provides methods to execute calls asynchronously.  It "
"should not be used directly, but through its concrete subclasses."
#: ../../library/concurrent.futures.rst:41
"Schedules the callable, *fn*, to be executed as ``fn(*args, **kwargs)`` and "
"returns a :class:`Future` object representing the execution of the "
"callable. ::"
#: ../../library/concurrent.futures.rst:45
"with ThreadPoolExecutor(max_workers=1) as executor:\n"
"    future = executor.submit(pow, 323, 1235)\n"
"    print(future.result())"
#: ../../library/concurrent.futures.rst:51
msgid "Similar to :func:`map(fn, *iterables) <map>` except:"
#: ../../library/concurrent.futures.rst:53
"The *iterables* are collected immediately rather than lazily, unless a "
"*buffersize* is specified to limit the number of submitted tasks whose "
"results have not yet been yielded. If the buffer is full, iteration over the "
"*iterables* pauses until a result is yielded from the buffer."
#: ../../library/concurrent.futures.rst:58
"*fn* is executed asynchronously and several calls to *fn* may be made "
"concurrently."
#: ../../library/concurrent.futures.rst:61
"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."
#: ../../library/concurrent.futures.rst:67
"If a *fn* call raises an exception, then that exception will be raised when "
"its value is retrieved from the iterator."
#: ../../library/concurrent.futures.rst:70
"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` "
"and :class:`InterpreterPoolExecutor`, *chunksize* has no effect."
#: ../../library/concurrent.futures.rst:79
msgid "Added the *chunksize* parameter."
#: ../../library/concurrent.futures.rst:82
msgid "Added the *buffersize* parameter."
#: ../../library/concurrent.futures.rst:87
"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`."
#: ../../library/concurrent.futures.rst:92
"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."
#: ../../library/concurrent.futures.rst:100
"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*."
#: ../../library/concurrent.futures.rst:105
"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."
#: ../../library/concurrent.futures.rst:109
"You can avoid having to call this method explicitly if you use the executor "
"as a :term:`context manager` via the  :keyword:`with` statement, which will "
"shutdown the :class:`Executor` (waiting as if :meth:`Executor.shutdown` were "
"called with *wait* set to ``True``)::"
#: ../../library/concurrent.futures.rst:114
"import shutil\n"
"with ThreadPoolExecutor(max_workers=4) as e:\n"
"    e.submit(shutil.copy, 'src1.txt', 'dest1.txt')\n"
"    e.submit(shutil.copy, 'src2.txt', 'dest2.txt')\n"
"    e.submit(shutil.copy, 'src3.txt', 'dest3.txt')\n"
"    e.submit(shutil.copy, 'src4.txt', 'dest4.txt')"
#: ../../library/concurrent.futures.rst:121
msgid "Added *cancel_futures*."
#: ../../library/concurrent.futures.rst:126
msgid "ThreadPoolExecutor"
#: ../../library/concurrent.futures.rst:128
":class:`ThreadPoolExecutor` is an :class:`Executor` subclass that uses a "
"pool of threads to execute calls asynchronously."
#: ../../library/concurrent.futures.rst:131
"Deadlocks can occur when the callable associated with a :class:`Future` "
"waits on the results of another :class:`Future`.  For example::"
#: ../../library/concurrent.futures.rst:134
"import time\n"
"def wait_on_b():\n"
"    time.sleep(5)\n"
"    print(b.result())  # b will never complete because it is waiting on a.\n"
"    return 5\n"
"def wait_on_a():\n"
"    time.sleep(5)\n"
"    print(a.result())  # a will never complete because it is waiting on b.\n"
"    return 6\n"
"executor = ThreadPoolExecutor(max_workers=2)\n"
"a = executor.submit(wait_on_b)\n"
"b = executor.submit(wait_on_a)"
#: ../../library/concurrent.futures.rst:150
msgid "And::"
#: ../../library/concurrent.futures.rst:152
"def wait_on_future():\n"
"    f = executor.submit(pow, 5, 2)\n"
"    # This will never complete because there is only one worker thread and\n"
"    # it is executing this function.\n"
"    print(f.result())\n"
"executor = ThreadPoolExecutor(max_workers=1)\n"
"future = executor.submit(wait_on_future)\n"
"# Note: calling future.result() would also cause a deadlock because\n"
"# the single worker thread is already waiting for wait_on_future()."
#: ../../library/concurrent.futures.rst:166
"An :class:`Executor` subclass that uses a pool of at most *max_workers* "
"threads to execute calls asynchronously."
#: ../../library/concurrent.futures.rst:169
"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."
#: ../../library/concurrent.futures.rst:176
"*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."
#: ../../library/concurrent.futures.rst:182
"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`."
#: ../../library/concurrent.futures.rst:190
"Added the *thread_name_prefix* parameter to allow users to control "
"the :class:`threading.Thread` names for worker threads created by the pool "
"for easier debugging."
#: ../../library/concurrent.futures.rst:195
#: ../../library/concurrent.futures.rst:405
msgid "Added the *initializer* and *initargs* arguments."
#: ../../library/concurrent.futures.rst:198
"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."
#: ../../library/concurrent.futures.rst:204
"ThreadPoolExecutor now reuses idle worker threads before starting "
"*max_workers* worker threads too."
#: ../../library/concurrent.futures.rst:207
"Default value of *max_workers* is changed to ``min(32, "
"(os.process_cpu_count() or 1) + 4)``."
#: ../../library/concurrent.futures.rst:215
msgid "ThreadPoolExecutor Example"
#: ../../library/concurrent.futures.rst:218
"import concurrent.futures\n"
"import urllib.request\n"
"URLS = ['http://www.foxnews.com/',\n"
"        'http://www.cnn.com/',\n"
"        'http://europe.wsj.com/',\n"
"        'http://www.bbc.co.uk/',\n"
"        'http://nonexistent-subdomain.python.org/']\n"
"# Retrieve a single page and report the URL and contents\n"
"def load_url(url, timeout):\n"
"    with urllib.request.urlopen(url, timeout=timeout) as conn:\n"
"        return conn.read()\n"
"# We can use a with statement to ensure threads are cleaned up promptly\n"
"with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:\n"
"    # Start the load operations and mark each future with its URL\n"
"    future_to_url = {executor.submit(load_url, url, 60): url for url in "
"    for future in concurrent.futures.as_completed(future_to_url):\n"
"        url = future_to_url[future]\n"
"        try:\n"
"            data = future.result()\n"
"        except Exception as exc:\n"
"            print('%r generated an exception: %s' % (url, exc))\n"
"        else:\n"
"            print('%r page is %d bytes' % (url, len(data)))"
#: ../../library/concurrent.futures.rst:247
msgid "InterpreterPoolExecutor"
#: ../../library/concurrent.futures.rst:251
"The :class:`InterpreterPoolExecutor` class uses a pool of interpreters to "
"execute calls asynchronously.  It is a :class:`ThreadPoolExecutor` subclass, "
"which means each worker is running in its own thread. The difference here is "
"that each worker has its own interpreter, and runs each task using that "
"interpreter."
#: ../../library/concurrent.futures.rst:257
"The biggest benefit to using interpreters instead of only threads is true "
"multi-core parallelism.  Each interpreter has its own :term:`Global "
"Interpreter Lock <global interpreter lock>`, so code running in one "
"interpreter can run on one CPU core, while code in another interpreter runs "
"unblocked on a different core."
#: ../../library/concurrent.futures.rst:263
"The tradeoff is that writing concurrent code for use with multiple "
"interpreters can take extra effort.  However, this is because it forces you "
"to be deliberate about how and when interpreters interact, and to be "
"explicit about what data is shared between interpreters. This results in "
"several benefits that help balance the extra effort, including true multi-"
"core parallelism,  For example, code written this way can make it easier to "
"reason about concurrency.  Another major benefit is that you don't have to "
"deal with several of the big pain points of using threads, like race "
"conditions."
#: ../../library/concurrent.futures.rst:273
"Each worker's interpreter is isolated from all the other interpreters. "
"\"Isolated\" means each interpreter has its own runtime state and operates "
"completely independently.  For example, if you redirect :data:`sys.stdout` "
"in one interpreter, it will not be automatically redirected to any other "
"interpreter.  If you import a module in one interpreter, it is not "
"automatically imported in any other.  You would need to import the module "
"separately in interpreter where you need it.  In fact, each module imported "
"in an interpreter is a completely separate object from the same module in a "
"different interpreter, including :mod:`sys`, :mod:`builtins`, and even "
"``__main__``."
#: ../../library/concurrent.futures.rst:285
"Isolation means a mutable object, or other data, cannot be used by more than "
"one interpreter at the same time.  That effectively means interpreters "
"cannot actually share such objects or data.  Instead, each interpreter must "
"have its own copy, and you will have to synchronize any changes between the "
"copies manually.  Immutable objects and data, like the builtin singletons, "
"strings, and tuples of immutable objects, don't have these limitations."
#: ../../library/concurrent.futures.rst:293
"Communicating and synchronizing between interpreters is most effectively "
"done using dedicated tools, like those proposed in :pep:`734`.  One less "
"efficient alternative is to serialize with :mod:`pickle` and then send the "
"bytes over a shared :mod:`socket <socket>` or :func:`pipe <os.pipe>`."
#: ../../library/concurrent.futures.rst:301
"A :class:`ThreadPoolExecutor` subclass that executes calls asynchronously "
"using a pool of at most *max_workers* threads.  Each thread runs tasks in "
"its own interpreter.  The worker interpreters are isolated from each other, "
"which means each has its own runtime state and that they can't share any "
"mutable objects or other data.  Each interpreter has its own :term:`Global "
"Interpreter Lock <global interpreter lock>`, which means code run with this "
"executor has true multi-core parallelism."
#: ../../library/concurrent.futures.rst:309
"The optional *initializer* and *initargs* arguments have the same meaning as "
"for :class:`!ThreadPoolExecutor`: the initializer is run when each worker is "
"created, though in this case it is run in the worker's interpreter.  The "
"executor serializes the *initializer* and *initargs* using :mod:`pickle` "
"when sending them to the worker's interpreter."
#: ../../library/concurrent.futures.rst:317
"The executor may replace uncaught exceptions from *initializer* "
"with :class:`~concurrent.interpreters.ExecutionFailed`."
#: ../../library/concurrent.futures.rst:320
msgid "Other caveats from parent :class:`ThreadPoolExecutor` apply here."
#: ../../library/concurrent.futures.rst:322
":meth:`~Executor.submit` and :meth:`~Executor.map` work like normal, except "
"the worker serializes the callable and arguments using :mod:`pickle` when "
"sending them to its interpreter.  The worker likewise serializes the return "
"value when sending it back."
#: ../../library/concurrent.futures.rst:327
"When a worker's current task raises an uncaught exception, the worker always "
"tries to preserve the exception as-is.  If that is successful then it also "
"sets the ``__cause__`` to a "
"corresponding :class:`~concurrent.interpreters.ExecutionFailed` instance, "
"which contains a summary of the original exception. In the uncommon case "
"that the worker is not able to preserve the original as-is then it directly "
"preserves the "
"corresponding :class:`~concurrent.interpreters.ExecutionFailed` instance "
#: ../../library/concurrent.futures.rst:339
msgid "ProcessPoolExecutor"
#: ../../library/concurrent.futures.rst:341
"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 "
"<global interpreter lock>` but also means that only picklable objects can be "
"executed and returned."
#: ../../library/concurrent.futures.rst:348
"The ``__main__`` module must be importable by worker subprocesses. This "
"means that :class:`ProcessPoolExecutor` will not work in the interactive "
"interpreter."
#: ../../library/concurrent.futures.rst:351
"Calling :class:`Executor` or :class:`Future` methods from a callable "
"submitted to a :class:`ProcessPoolExecutor` will result in deadlock."
#: ../../library/concurrent.futures.rst:354
"Note that the restrictions on functions and arguments needing to picklable "
"as per :class:`multiprocessing.Process` apply when "
"using :meth:`~Executor.submit` and :meth:`~Executor.map` on "
"a :class:`ProcessPoolExecutor`. A function defined in a REPL or a lambda "
"should not be expected to work."
#: ../../library/concurrent.futures.rst:361
"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 :func:`os.process_cpu_count`. 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 :mod:`multiprocessing` context or ``None``. "
"It will be used to launch the workers. If *mp_context* is ``None`` or not "
"given, the default :mod:`multiprocessing` context is used. "
"See :ref:`multiprocessing-start-methods`."
#: ../../library/concurrent.futures.rst:375
"*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."
#: ../../library/concurrent.futures.rst:381
"*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."
#: ../../library/concurrent.futures.rst:390
"Bugs have been reported when using the *max_tasks_per_child* feature that "
"can result in the :class:`ProcessPoolExecutor` hanging in some "
"circumstances. Follow its eventual resolution in :gh:`115634`."
#: ../../library/concurrent.futures.rst:394
"When one of the worker processes terminates abruptly, "
"a :exc:`~concurrent.futures.process.BrokenProcessPool` error is now raised. "
"Previously, behaviour was undefined but operations on the executor or its "
"futures would often freeze or deadlock."
#: ../../library/concurrent.futures.rst:401
"The *mp_context* argument was added to allow users to control the "
"start_method for worker processes created by the pool."
#: ../../library/concurrent.futures.rst:407
"The *max_tasks_per_child* argument was added to allow users to control the "
"lifetime of workers in the pool."
#: ../../library/concurrent.futures.rst:411
"On POSIX systems, if your application has multiple threads and "
"the :mod:`multiprocessing` context uses the ``\"fork\"`` start method: "
"The :func:`os.fork` function called internally to spawn workers may raise "
"a :exc:`DeprecationWarning`. Pass a *mp_context* configured to use a "
"different start method. See the :func:`os.fork` documentation for further "
"explanation."
#: ../../library/concurrent.futures.rst:419
"*max_workers* uses :func:`os.process_cpu_count` by default, instead "
"of :func:`os.cpu_count`."
#: ../../library/concurrent.futures.rst:423
"The default process start method (see :ref:`multiprocessing-start-methods`) "
"changed away from *fork*. If you require the *fork* start method "
"for :class:`ProcessPoolExecutor` you must explicitly pass "
"``mp_context=multiprocessing.get_context(\"fork\")``."
#: ../../library/concurrent.futures.rst:431
"Attempt to terminate all living worker processes immediately by "
"calling :meth:`Process.terminate <multiprocessing.Process.terminate>` on "
"each of them. Internally, it will also call :meth:`Executor.shutdown` to "
"ensure that all other resources associated with the executor are freed."
#: ../../library/concurrent.futures.rst:436
#: ../../library/concurrent.futures.rst:448
"After calling this method the caller should no longer submit tasks to the "
"executor."
#: ../../library/concurrent.futures.rst:443
"Attempt to kill all living worker processes immediately by "
"calling :meth:`Process.kill <multiprocessing.Process.kill>` on each of them. "
"Internally, it will also call :meth:`Executor.shutdown` to ensure that all "
"other resources associated with the executor are freed."
#: ../../library/concurrent.futures.rst:456
msgid "ProcessPoolExecutor Example"
#: ../../library/concurrent.futures.rst:459
"import concurrent.futures\n"
"import math\n"
"PRIMES = [\n"
"    112272535095293,\n"
"    112582705942171,\n"
"    112272535095293,\n"
"    115280095190773,\n"
"    115797848077099,\n"
"def is_prime(n):\n"
"    if n < 2:\n"
"        return False\n"
"    if n == 2:\n"
"        return True\n"
"    if n % 2 == 0:\n"
"        return False\n"
"    sqrt_n = int(math.floor(math.sqrt(n)))\n"
"    for i in range(3, sqrt_n + 1, 2):\n"
"        if n % i == 0:\n"
"            return False\n"
"    return True\n"
"def main():\n"
"    with concurrent.futures.ProcessPoolExecutor() as executor:\n"
"        for number, prime in zip(PRIMES, executor.map(is_prime, PRIMES)):\n"
"            print('%d is prime: %s' % (number, prime))\n"
"if __name__ == '__main__':\n"
"    main()"
#: ../../library/concurrent.futures.rst:494
msgid "Future Objects"
#: ../../library/concurrent.futures.rst:496
"The :class:`Future` class encapsulates the asynchronous execution of a "
"callable. :class:`Future` instances are created by :meth:`Executor.submit`."
#: ../../library/concurrent.futures.rst:501
"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."
#: ../../library/concurrent.futures.rst:507
"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``."
#: ../../library/concurrent.futures.rst:514
msgid "Return ``True`` if the call was successfully cancelled."
#: ../../library/concurrent.futures.rst:518
"Return ``True`` if the call is currently being executed and cannot be "
"cancelled."
#: ../../library/concurrent.futures.rst:523
"Return ``True`` if the call was successfully cancelled or finished running."
#: ../../library/concurrent.futures.rst:528
"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."
#: ../../library/concurrent.futures.rst:535
#: ../../library/concurrent.futures.rst:549
"If the future is cancelled before completing then :exc:`.CancelledError` "
"will be raised."
#: ../../library/concurrent.futures.rst:538
"If the call raised an exception, this method will raise the same exception."
#: ../../library/concurrent.futures.rst:542
"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."
#: ../../library/concurrent.futures.rst:552
msgid "If the call completed without raising, ``None`` is returned."
#: ../../library/concurrent.futures.rst:556
"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 "
#: ../../library/concurrent.futures.rst:560
"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."
#: ../../library/concurrent.futures.rst:566
"If the future has already completed or been cancelled, *fn* will be called "
"immediately."
#: ../../library/concurrent.futures.rst:569
"The following :class:`Future` methods are meant for use in unit tests "
"and :class:`Executor` implementations."
#: ../../library/concurrent.futures.rst:574
"This method should only be called by :class:`Executor` implementations "
"before executing the work associated with the :class:`Future` and by unit "
#: ../../library/concurrent.futures.rst:578
"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."
#: ../../library/concurrent.futures.rst:583
"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``."
#: ../../library/concurrent.futures.rst:587
"This method can only be called once and cannot be called "
"after :meth:`Future.set_result` or :meth:`Future.set_exception` have been "
#: ../../library/concurrent.futures.rst:593
"Sets the result of the work associated with the :class:`Future` to *result*."
#: ../../library/concurrent.futures.rst:596
#: ../../library/concurrent.futures.rst:609
"This method should only be used by :class:`Executor` implementations and "
"unit tests."
#: ../../library/concurrent.futures.rst:599
#: ../../library/concurrent.futures.rst:612
"This method raises :exc:`concurrent.futures.InvalidStateError` if "
"the :class:`Future` is already done."
#: ../../library/concurrent.futures.rst:606
"Sets the result of the work associated with the :class:`Future` to "
"the :class:`Exception` *exception*."
#: ../../library/concurrent.futures.rst:618
msgid "Module Functions"
#: ../../library/concurrent.futures.rst:622
"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)."
#: ../../library/concurrent.futures.rst:630
"*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."
#: ../../library/concurrent.futures.rst:634
"*return_when* indicates when this function should return.  It must be one of "
"the following constants:"
#: ../../library/concurrent.futures.rst:640
msgid "Constant"
#: ../../library/concurrent.futures.rst:641
msgid "Description"
#: ../../library/concurrent.futures.rst:644
msgid "The function will return when any future finishes or is cancelled."
#: ../../library/concurrent.futures.rst:647
"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`."
#: ../../library/concurrent.futures.rst:652
msgid "The function will return when all futures finish or are cancelled."
#: ../../library/concurrent.futures.rst:656
"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."
#: ../../library/concurrent.futures.rst:669
msgid ":pep:`3148` -- futures - execute computations asynchronously"
#: ../../library/concurrent.futures.rst:670
"The proposal which described this feature for inclusion in the Python "
"standard library."
#: ../../library/concurrent.futures.rst:675
msgid "Exception classes"
#: ../../library/concurrent.futures.rst:681
msgid "Raised when a future is cancelled."
#: ../../library/concurrent.futures.rst:685
"A deprecated alias of :exc:`TimeoutError`, raised when a future operation "
"exceeds the given timeout."
#: ../../library/concurrent.futures.rst:690
msgid "This class was made an alias of :exc:`TimeoutError`."
#: ../../library/concurrent.futures.rst:695
"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."
#: ../../library/concurrent.futures.rst:703
"Raised when an operation is performed on a future that is not allowed in the "
"current state."
#: ../../library/concurrent.futures.rst:712
"Derived from :exc:`~concurrent.futures.BrokenExecutor`, this exception class "
"is raised when one of the workers of "
"a :class:`~concurrent.futures.ThreadPoolExecutor` has failed initializing."
#: ../../library/concurrent.futures.rst:723
"Derived from :exc:`~concurrent.futures.thread.BrokenThreadPool`, this "
"exception class is raised when one of the workers of "
"a :class:`~concurrent.futures.InterpreterPoolExecutor` has failed "
"initializing."
#: ../../library/concurrent.futures.rst:734
"Derived from :exc:`~concurrent.futures.BrokenExecutor` "
"(formerly :exc:`RuntimeError`), this exception class is raised when one of "
"the workers of a :class:`~concurrent.futures.ProcessPoolExecutor` has "
"terminated in a non-clean fashion (for example, if it was killed from the "
"outside)."
Navigation Menu

Uh oh!

Uh oh!

FilesExpand file tree

concurrent.futures.po

Latest commit

History

concurrent.futures.po

File metadata and controls
