# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Masato HASHIMOTO <cabezon.hashimoto@gmail.com>, 2017
# 秘湯 <xwhhsprings@gmail.com>, 2017
# Nozomu Kaneko <nozom.kaneko@gmail.com>, 2017
# Yusuke Miyazaki <miyazaki.dev@gmail.com>, 2017
# Shun Sakurai, 2017
# Arihiro TAKASE, 2017
# E. Kawashima, 2017
# Osamu NAKAMURA, 2017
# mollinaca, 2020
# Takanori Suzuki <takanori@takanory.net>, 2021
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.9\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-07-29 07:05+0000\n"
"PO-Revision-Date: 2017-02-16 23:03+0000\n"
"Last-Translator: Takanori Suzuki <takanori@takanory.net>, 2021\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"Language: ja\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/concurrent.futures.rst:2
msgid ":mod:`concurrent.futures` --- Launching parallel tasks"
msgstr ":mod:`concurrent.futures` -- 並列タスク実行"

#: ../../library/concurrent.futures.rst:9
msgid ""
"**Source code:** :source:`Lib/concurrent/futures/thread.py` and :source:`Lib/"
"concurrent/futures/process.py`"
msgstr ""
"**ソースコード:** :source:`Lib/concurrent/futures/thread.py` および :source:"
"`Lib/concurrent/futures/process.py`"

#: ../../library/concurrent.futures.rst:14
msgid ""
"The :mod:`concurrent.futures` module provides a high-level interface for "
"asynchronously executing callables."
msgstr ""
":mod:`concurrent.futures` モジュールは、非同期に実行できる呼び出し可能オブ"
"ジェクトの高水準のインターフェースを提供します。"

#: ../../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 ""
"非同期実行は :class:`ThreadPoolExecutor` を用いてスレッドで実行すること"
"も、  :class:`ProcessPoolExecutor` を用いて別々のプロセスで実行することもでき"
"ます.  どちらも :class:`Executor` 抽象クラスで定義された同じインターフェース"
"を実装します。"

#: ../../library/concurrent.futures.rst:24
msgid "Executor Objects"
msgstr "Executor オブジェクト"

#: ../../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 ""
"非同期呼び出しを実行するためのメソッドを提供する抽象クラスです。このクラスを"
"直接使ってはならず、具象サブクラスを介して使います。"

#: ../../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 ""
"呼び出し可能オブジェクト *fn* を、 ``fn(*args **kwargs)`` として実行するよう"
"にスケジュールし、呼び出し可能オブジェクトの実行を表現する :class:`Future` オ"
"ブジェクトを返します。 ::"

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

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

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

#: ../../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 ""
"もし :meth:`~iterator.__next__` が呼ばれその結果が元々の呼び出しから "
"*timeout* 秒経った後も利用できない場合、返されるイテレータは :exc:"
"`concurrent.futures.TimeoutError` を送出します。*timeout* は整数または浮動小"
"数点数です。もし *timeout* が指定されないか の場合、待ち時間に制限はありませ"
"ん。"

#: ../../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 ""
"もし *func* の呼び出しが例外を送出した場合、その例外はイテレータから値を受け"
"取る時に送出されます。"

#: ../../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 ""

#: ../../library/concurrent.futures.rst:67
msgid "Added the *chunksize* argument."
msgstr "*chunksize* 引数が追加されました。"

#: ../../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 ""
"executor に対して、現在保留中のフューチャーが実行された後で、使用中のすべての"
"資源を解放するように伝えます。シャットダウンにより後に :meth:`Executor."
"submit` と :meth:`Executor.map` を呼び出すと :exc:`RuntimeError` が送出されま"
"す。"

#: ../../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 ""
"*wait* が ``True`` の場合、すべての未完了のフューチャの実行が完了して "
"Executor に関連付けられたリソースが解放されるまで、このメソッドは返りませ"
"ん。 *wait* が ``False`` の場合、このメソッドはすぐに返り、すべての未完了の"
"フューチャの実行が完了したときに、 Executor に関連付けられたリソースが解放さ"
"れます。 *wait* の値に関係なく、すべての未完了のフューチャの実行が完了するま"
"で Python プログラム全体は終了しません。"

#: ../../library/concurrent.futures.rst:85
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:90
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:94
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 ""
":keyword:`with` 文を使用することで、このメソッドを明示的に呼ばないようにでき"
"ます。 :keyword:`with` 文は  :class:`Executor` をシャットダウンします "
"(*wait* を ``True`` にセットして :meth:`Executor.shutdown` が呼ばれたかのよう"
"に待ちます)。"

#: ../../library/concurrent.futures.rst:106
msgid "Added *cancel_futures*."
msgstr "*cancel_futures* が追加されました。"

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

#: ../../library/concurrent.futures.rst:113
msgid ""
":class:`ThreadPoolExecutor` is an :class:`Executor` subclass that uses a "
"pool of threads to execute calls asynchronously."
msgstr ""
":class:`ThreadPoolExecutor` はスレッドのプールを使用して非同期に呼び出しを行"
"う、 :class:`Executor` のサブクラスです。"

#: ../../library/concurrent.futures.rst:116
msgid ""
"Deadlocks can occur when the callable associated with a :class:`Future` "
"waits on the results of another :class:`Future`.  For example::"
msgstr ""
":class:`Future` に関連づけられた呼び出し可能オブジェクトが、別の :class:"
"`Future` の結果を待つ時にデッドロックすることがあります。例::"

#: ../../library/concurrent.futures.rst:135
msgid "And::"
msgstr "以下でも同様です::"

#: ../../library/concurrent.futures.rst:149
msgid ""
"An :class:`Executor` subclass that uses a pool of at most *max_workers* "
"threads to execute calls asynchronously."
msgstr ""
"最大で *max_workers* 個のスレッドを非同期実行に使う :class:`Executor` のサブ"
"クラスです。"

#: ../../library/concurrent.futures.rst:152
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:158
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 ""
"*max_workers* が ``None`` か指定されない場合のデフォルト値はマシンのプロセッ"
"サの数に 5 を掛けたものになります。これは、 :class:`ThreadPoolExecutor` は "
"CPU の処理ではなく I/O をオーバーラップするのによく使用されるため、 :class:"
"`ProcessPoolExecutor` のワーカーの数よりもこのワーカーの数を増やすべきである"
"という想定に基づいています。"

#: ../../library/concurrent.futures.rst:166
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 ""
"*thread_name_prefix* 引数が追加され、デバッグしやすくなるようにプールから作ら"
"れたワーカスレッド :class:`threading.Thread` の名前を管理できるようになりまし"
"た。"

#: ../../library/concurrent.futures.rst:171
#: ../../library/concurrent.futures.rst:265
msgid "Added the *initializer* and *initargs* arguments."
msgstr "*initializer* と *initargs* 引数が追加されました。"

#: ../../library/concurrent.futures.rst:174
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:180
msgid ""
"ThreadPoolExecutor now reuses idle worker threads before starting "
"*max_workers* worker threads too."
msgstr ""

#: ../../library/concurrent.futures.rst:187
msgid "ThreadPoolExecutor Example"
msgstr "ThreadPoolExecutor の例"

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

#: ../../library/concurrent.futures.rst:221
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 <global interpreter "
"lock>` but also means that only picklable objects can be executed and "
"returned."
msgstr ""
":class:`ProcessPoolExecutor`  はプロセスプールを使って非同期呼び出しを実施す"
"る :class:`Executor` のサブクラスです。:class:`ProcessPoolExecutor` は :mod:"
"`multiprocessing` モジュールを利用します。このため :term:`Global Interpreter "
"Lock <global interpreter lock>` を回避することができますが、pickle 化できるオ"
"ブジェクトしか実行したり返したりすることができません。"

#: ../../library/concurrent.futures.rst:228
msgid ""
"The ``__main__`` module must be importable by worker subprocesses. This "
"means that :class:`ProcessPoolExecutor` will not work in the interactive "
"interpreter."
msgstr ""
"``__main__`` モジュールはワーカサブプロセスでインポート可能でなければなりませ"
"ん。\n"
"すなわち、 :class:`ProcessPoolExecutor` は対話的インタープリタでは動きませ"
"ん。"

#: ../../library/concurrent.futures.rst:231
msgid ""
"Calling :class:`Executor` or :class:`Future` methods from a callable "
"submitted to a :class:`ProcessPoolExecutor` will result in deadlock."
msgstr ""
":class:`ProcessPoolExecutor` に渡された呼び出し可能オブジェクトから :class:"
"`Executor` や :class:`Future` メソッドを呼ぶとデッドロックに陥ります。"

#: ../../library/concurrent.futures.rst:236
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:249
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:255
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 ""
"ワーカプロセスの1つが突然終了した場合、:exc:`BrokenProcessPool` エラーが送出"
"されるようになりました。\n"
"以前は挙動は未定義でしたが、 executor や  futures がフリーズしたりデッドロッ"
"クを起こすことがしばしばでした。"

#: ../../library/concurrent.futures.rst:261
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:271
msgid "ProcessPoolExecutor Example"
msgstr "ProcessPoolExecutor の例"

#: ../../library/concurrent.futures.rst:309
msgid "Future Objects"
msgstr "Future オブジェクト"

#: ../../library/concurrent.futures.rst:311
msgid ""
"The :class:`Future` class encapsulates the asynchronous execution of a "
"callable. :class:`Future` instances are created by :meth:`Executor.submit`."
msgstr ""
":class:`Future` クラスは呼び出し可能オブジェクトの非同期実行をカプセル化しま"
"す。 :class:`Future` のインスタンスは :meth:`Executor.submit` によって生成さ"
"れます。"

#: ../../library/concurrent.futures.rst:316
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 ""
"呼び出し可能オブジェクトの非同期実行をカプセル化します。 :class:`Future` イン"
"スタンスは :meth:`Executor.submit` で生成され、テストを除いて直接生成すべきで"
"はありません。"

#: ../../library/concurrent.futures.rst:322
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:329
msgid "Return ``True`` if the call was successfully cancelled."
msgstr "呼び出しが正常にキャンセルされた場合 ``True`` を返します。"

#: ../../library/concurrent.futures.rst:333
msgid ""
"Return ``True`` if the call is currently being executed and cannot be "
"cancelled."
msgstr "現在呼び出しが実行中でキャンセルできない場合 ``True`` を返します。"

#: ../../library/concurrent.futures.rst:338
msgid ""
"Return ``True`` if the call was successfully cancelled or finished running."
msgstr "呼び出しが正常にキャンセルされたか終了した場合 ``True`` を返します。"

#: ../../library/concurrent.futures.rst:343
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 ""
"呼び出しによって返された値を返します。呼び出しがまだ完了していない場合、この"
"メソッドは *timeout* 秒の間待機します。呼び出しが *timeout* 秒間の間に完了し"
"ない場合、 :exc:`concurrent.futures.TimeoutError` が送出されます。 *timeout* "
"にはintかfloatを指定できます。*timeout* が指定されていないか、 ``None`` であ"
"る場合、待機時間に制限はありません。"

#: ../../library/concurrent.futures.rst:350
#: ../../library/concurrent.futures.rst:364
msgid ""
"If the future is cancelled before completing then :exc:`.CancelledError` "
"will be raised."
msgstr ""
"future が完了する前にキャンセルされた場合 :exc:`CancelledError` が送出されま"
"す。"

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

#: ../../library/concurrent.futures.rst:357
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 ""
"呼び出しによって送出された例外を返します。呼び出しがまだ完了していない場合、"
"このメソッドは *timeout* 秒だけ待機します。呼び出しが *timeout* 秒の間に完了"
"しない場合、 :exc:`concurrent.futures.TimeoutError` が送出されます。 "
"*timeout* にはintかfloatを指定できます。 *timeout* が指定されていないか、 "
"``None`` である場合、待機時間に制限はありません。"

#: ../../library/concurrent.futures.rst:367
msgid "If the call completed without raising, ``None`` is returned."
msgstr "呼び出しが例外を送出することなく完了した場合、``None`` を返します。"

#: ../../library/concurrent.futures.rst:371
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 ""
"呼び出し可能な *fn* オブジェクトを future にアタッチします。futureがキャンセ"
"ルされたか、実行を終了した際に、future をそのただ一つの引数として *fn* が呼び"
"出されます。"

#: ../../library/concurrent.futures.rst:375
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 ""
"追加された呼び出し可能オブジェクトは、追加された順番で呼びだされ、追加を行っ"
"たプロセスに属するスレッド中で呼び出されます。もし呼び出し可能オブジェクト"
"が :exc:`Exception` のサブクラスを送出した場合、それはログに記録され無視され"
"ます。呼び出し可能オブジェクトが :exc:`BaseException` のサブクラスを送出した"
"場合の動作は未定義です。"

#: ../../library/concurrent.futures.rst:381
msgid ""
"If the future has already completed or been cancelled, *fn* will be called "
"immediately."
msgstr ""
"もしfutureがすでに完了しているか、キャンセル済みであれば、*fn* は即座に実行さ"
"れます。"

#: ../../library/concurrent.futures.rst:384
msgid ""
"The following :class:`Future` methods are meant for use in unit tests and :"
"class:`Executor` implementations."
msgstr ""
"以下の :class:`Future` メソッドは、ユニットテストでの使用と :class:"
"`Executor` を実装することを意図しています。"

#: ../../library/concurrent.futures.rst:389
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 ""
"このメソッドは、:class:`Future` に関連付けられたワークやユニットテストによる"
"ワークの実行前に、 :class:`Executor` の実装によってのみ呼び出してください。"

#: ../../library/concurrent.futures.rst:393
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 ""
"このメソッドが ``False`` を返す場合、 :class:`Future` はキャンセルされていま"
"す。つまり、 :meth:`Future.cancel` が呼び出されて `True` が返っています。:"
"class:`Future` の完了を  (:func:`as_completed` または :func:`wait` により)  "
"待機するすべてのスレッドが起動します。"

#: ../../library/concurrent.futures.rst:398
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 ""
"このメソッドが ``True`` を返す場合、 :class:`Future` はキャンセルされて、実行"
"状態に移行されています。つまり、 :meth:`Future.running` を呼び出すと `True` "
"が返ります。"

#: ../../library/concurrent.futures.rst:402
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 ""
"このメソッドは、一度だけ呼び出すことができ、:meth:`Future.set_result` また"
"は :meth:`Future.set_exception` がキャンセルされた後には呼び出すことができま"
"せん。"

#: ../../library/concurrent.futures.rst:408
msgid ""
"Sets the result of the work associated with the :class:`Future` to *result*."
msgstr ":class:`Future` に関連付けられたワークの結果を *result* に設定します。"

#: ../../library/concurrent.futures.rst:411
#: ../../library/concurrent.futures.rst:424
msgid ""
"This method should only be used by :class:`Executor` implementations and "
"unit tests."
msgstr ""
"このメソッドは、 :class:`Executor` の実装またはユニットテストによってのみ使用"
"してください。"

#: ../../library/concurrent.futures.rst:414
#: ../../library/concurrent.futures.rst:427
msgid ""
"This method raises :exc:`concurrent.futures.InvalidStateError` if the :class:"
"`Future` is already done."
msgstr ""

#: ../../library/concurrent.futures.rst:421
msgid ""
"Sets the result of the work associated with the :class:`Future` to the :"
"class:`Exception` *exception*."
msgstr ""
":class:`Future` に関連付けられたワークの結果を :class:`Exception` "
"*exception* に設定します。"

#: ../../library/concurrent.futures.rst:433
msgid "Module Functions"
msgstr "モジュール関数"

#: ../../library/concurrent.futures.rst:437
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 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:444
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 ""
"*timeout* で結果を返すまで待機する最大秒数を指定できます。*timeout* は整数か"
"浮動小数点数をとります。*timeout* が指定されないか ``None`` の場合、無期限に"
"待機します。"

#: ../../library/concurrent.futures.rst:448
msgid ""
"*return_when* indicates when this function should return.  It must be one of "
"the following constants:"
msgstr ""
"*return_when* でこの関数がいつ結果を返すか指定します。指定できる値は以下の 定"
"数のどれか一つです:"

#: ../../library/concurrent.futures.rst:454
msgid "Constant"
msgstr "定数"

#: ../../library/concurrent.futures.rst:454
msgid "Description"
msgstr "説明"

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

#: ../../library/concurrent.futures.rst:456
msgid "The function will return when any future finishes or is cancelled."
msgstr "いずれかのフューチャが終了したかキャンセルされたときに返します。"

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

#: ../../library/concurrent.futures.rst:459
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 ""
"いずれかのフューチャが例外の送出で終了した場合に返します。例外を送出した"
"フューチャがない場合は、:const:`ALL_COMPLETED` と等価になります。"

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

#: ../../library/concurrent.futures.rst:465
msgid "The function will return when all futures finish or are cancelled."
msgstr "すべてのフューチャが終了したかキャンセルされたときに返します。"

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

#: ../../library/concurrent.futures.rst:485
msgid ":pep:`3148` -- futures - execute computations asynchronously"
msgstr ":pep:`3148` -- futures - execute computations asynchronously"

#: ../../library/concurrent.futures.rst:485
msgid ""
"The proposal which described this feature for inclusion in the Python "
"standard library."
msgstr "この機能を Python 標準ライブラリに含めることを述べた提案です。"

#: ../../library/concurrent.futures.rst:490
msgid "Exception classes"
msgstr "例外クラス"

#: ../../library/concurrent.futures.rst:496
msgid "Raised when a future is cancelled."
msgstr "future がキャンセルされたときに送出されます。"

#: ../../library/concurrent.futures.rst:500
msgid "Raised when a future operation exceeds the given timeout."
msgstr "future の操作が与えられたタイムアウトを超過したときに送出されます。"

#: ../../library/concurrent.futures.rst:504
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:512
msgid ""
"Raised when an operation is performed on a future that is not allowed in the "
"current state."
msgstr ""

#: ../../library/concurrent.futures.rst:521
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:531
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 ""
":exc:`~concurrent.futures.BrokenExecutor` から派生しています(以前は :exc:"
"`RuntimeError` でした)。\n"
"この例外クラスは :class:`ProcessPoolExecutor` のワーカの1つが正常に終了されな"
"かったとき (例えば外部から kill されたとき) に送出されます。"