asyncio-task.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2018, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2018-06-30 05:56+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: SHIMIZU Taku <shimizu.taku@gmail.com>, 2018\n"
"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/asyncio-task.rst:4
msgid "Tasks and coroutines"
msgstr "タスクとコルーチン"

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

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

#: ../../library/asyncio-task.rst:13
msgid "Coroutines"
msgstr "コルーチン"

#: ../../library/asyncio-task.rst:15
msgid ""
"Coroutines used with :mod:`asyncio` may be implemented using the "
":keyword:`async def` statement, or by using :term:`generators <generator>`. "
"The :keyword:`async def` type of coroutine was added in Python 3.5, and is "
"recommended if there is no need to support older Python versions."
msgstr ""
":mod:`asyncio` と一緒に使うコルーチンは :keyword:`async def` 文を使って実装するか、もしくは  "
":term:`ジェネレータ <generator>` を使って実装します。:keyword:`async def` 型のコルーチンはPython "
"3.5の時に追加されました。3.5より前のバージョンのPythonをサポートする必要がなければ :keyword:`async def` "
"タイプのコルーチンが推奨されています。"

#: ../../library/asyncio-task.rst:20
msgid ""
"Generator-based coroutines should be decorated with "
":func:`@asyncio.coroutine <asyncio.coroutine>`, although this is not "
"strictly enforced. The decorator enables compatibility with :keyword:`async "
"def` coroutines, and also serves as documentation.  Generator-based "
"coroutines use the ``yield from`` syntax introduced in :pep:`380`, instead "
"of the original ``yield`` syntax."
msgstr ""
"必須というわけではありませんが、ジェネレータベースのコルーチンは :func:`@asyncio.coroutine "
"<asyncio.coroutine>` でデコレートすべきです。 :func:`@asyncio.coroutine "
"<asyncio.coroutine>` でデコレートすることで :keyword:`async def` "
"型のコルーチンと互換性を持たせることができ、ドキュメントとしても役に立ちます。ジェネレータベースのコルーチンは ``yield`` 構文を使う代わりに、"
" :pep:`380` で導入された ``yield from`` 構文を使います。"

#: ../../library/asyncio-task.rst:27
msgid ""
"The word \"coroutine\", like the word \"generator\", is used for two "
"different (though related) concepts:"
msgstr "単語 \"コルーチン\" は単語 \"ジェネレーター\" のように、(関連はしていますが) 異なる 2 つの概念で使用されます:"

#: ../../library/asyncio-task.rst:30
msgid ""
"The function that defines a coroutine (a function definition using "
":keyword:`async def` or decorated with ``@asyncio.coroutine``).  If "
"disambiguation is needed we will call this a *coroutine function* "
"(:func:`iscoroutinefunction` returns ``True``)."
msgstr ""
"コルーチンを定義した関数 (:keyword:`async def` を使用するか ``@asyncio.coroutine`` でデコレートされた関数定義)。\n"
"曖昧さを避ける際は *コルーチン関数* と呼びます (:func:`iscoroutinefunction` は ``True`` を返します)。"

#: ../../library/asyncio-task.rst:36
msgid ""
"The object obtained by calling a coroutine function.  This object represents"
" a computation or an I/O operation (usually a combination) that will "
"complete eventually.  If disambiguation is needed we will call it a "
"*coroutine object* (:func:`iscoroutine` returns ``True``)."
msgstr ""
"コルーチン関数の呼び出しによって取得されたオブジェクト。このオブジェクトは、いつかは完了する計算または I/O 操作 (通常はその組み合わせ) "
"を表します。曖昧さの解消が必要な場合はこれを *コルーチンオブジェクト* (:func:`iscoroutine` が ``True`` を返す) "
"と呼びます。"

#: ../../library/asyncio-task.rst:41
msgid "Things a coroutine can do:"
msgstr "コルーチンができること:"

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

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

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

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

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

#: ../../library/asyncio-task.rst:70
msgid "Coroutines (and tasks) can only run when the event loop is running."
msgstr "コルーチン (およびタスク) はイベントループが実行中の場合にのみ起動できます。"

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

#: ../../library/asyncio-task.rst:80
msgid ""
"There is no need to decorate :keyword:`async def` coroutines themselves."
msgstr ":keyword:`async def` コルーチン自身をデコレートする必要はありません。"

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

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

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

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

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

#: ../../library/asyncio-task.rst:106
msgid ""
"This function always creates a new event loop and closes it at the end.  It "
"should be used as a main entry point for asyncio programs, and should "
"ideally only be called once."
msgstr ""

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

#: ../../library/asyncio-task.rst:118
msgid "Example: Hello World coroutine"
msgstr "例: Hello World コルーチン"

#: ../../library/asyncio-task.rst:120
msgid "Example of coroutine displaying ``\"Hello World\"``::"
msgstr "``\"Hello World\"`` と表示するコルーチンの例::"

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

#: ../../library/asyncio-task.rst:139
msgid "Example: Coroutine displaying the current date"
msgstr "例: 現在の日時を表示するコルーチン"

#: ../../library/asyncio-task.rst:141
msgid ""
"Example of coroutine displaying the current date every second during 5 "
"seconds using the :meth:`sleep` function::"
msgstr ":meth:`sleep` 関数を用いて現在の時刻を5秒間、毎秒表示するコルーチンの例::"

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

#: ../../library/asyncio-task.rst:166
msgid "Example: Chain coroutines"
msgstr "例: コルーチンのチェーン"

#: ../../library/asyncio-task.rst:168
msgid "Example chaining coroutines::"
msgstr "コルーチンをチェーンする例です::"

#: ../../library/asyncio-task.rst:185
msgid ""
"``compute()`` is chained to ``print_sum()``: ``print_sum()`` coroutine waits"
" until ``compute()`` is completed before returning its result."
msgstr ""
"``compute()`` は ``print_sum()`` にチェーンされます: ``print_sum()`` コルーチンは "
"``compute()`` が完了するまで待ちます。"

#: ../../library/asyncio-task.rst:188
msgid "Sequence diagram of the example:"
msgstr "この例のシーケンス図です:"

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

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

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

#: ../../library/asyncio-task.rst:206
msgid "The operation is not allowed in this state."
msgstr "操作はこの状態では許可されません。"

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

#: ../../library/asyncio-task.rst:214
msgid "The operation exceeded the given deadline."
msgstr "操作は与えられた期限を超えました。"

#: ../../library/asyncio-task.rst:218
msgid ""
"This exception is different from the builtin :exc:`TimeoutError` exception!"
msgstr "この例外は組み込みの :exc:`TimeoutError` 例外とは異なります！"

#: ../../library/asyncio-task.rst:222
msgid "Future"
msgstr "フューチャー"

#: ../../library/asyncio-task.rst:226
msgid ""
"This class is *almost* compatible with :class:`concurrent.futures.Future`."
msgstr "このクラスは :class:`concurrent.futures.Future` と *ほぼ* 互換です。"

#: ../../library/asyncio-task.rst:228
msgid "Differences:"
msgstr "相違点:"

#: ../../library/asyncio-task.rst:230
msgid ""
":meth:`result` and :meth:`exception` do not take a timeout argument and "
"raise an exception when the future isn't done yet."
msgstr ""
":meth:`result` および :meth:`exception` "
"はタイムアウト引数を取らず、フューチャがまだ終了していないとき例外を送出します。"

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

#: ../../library/asyncio-task.rst:236
msgid ""
"This class is not compatible with the :func:`~concurrent.futures.wait` and "
":func:`~concurrent.futures.as_completed` functions in the "
":mod:`concurrent.futures` package."
msgstr ""
"このクラスは :mod:`concurrent.futures` パッケージの :func:`~concurrent.futures.wait` および"
" :func:`~concurrent.futures.as_completed` 関数との互換性はありません。"

#: ../../library/asyncio-task.rst:240 ../../library/asyncio-task.rst:436
msgid "This class is :ref:`not thread safe <asyncio-multithreading>`."
msgstr "このクラスは :ref:`スレッド安全ではありません <asyncio-multithreading>`。"

#: ../../library/asyncio-task.rst:244
msgid "Cancel the future and schedule callbacks."
msgstr "フューチャとスケジュールされたコールバックをキャンセルします。"

#: ../../library/asyncio-task.rst:246
msgid ""
"If the future is already done or cancelled, return ``False``. Otherwise, "
"change the future's state to cancelled, schedule the callbacks and return "
"``True``."
msgstr ""
"フューチャがすでに終了しているかキャンセルされていた場合 ``False`` "
"を返し、そうでない場合フューチャの状態をキャンセルに変更し、コールバックをスケジュールし、``True`` を返します。"

#: ../../library/asyncio-task.rst:252
msgid "Return ``True`` if the future was cancelled."
msgstr "フューチャがキャンセルされていた場合 ``True`` を返します。"

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

#: ../../library/asyncio-task.rst:258
msgid ""
"Done means either that a result / exception are available, or that the "
"future was cancelled."
msgstr "終了とは、結果が返された、例外が送出された、あるいはフューチャがキャンセルされたことを意味します。"

#: ../../library/asyncio-task.rst:263
msgid "Return the result this future represents."
msgstr "このフューチャが表す結果を返します。"

#: ../../library/asyncio-task.rst:265
msgid ""
"If the future has been cancelled, raises :exc:`CancelledError`. If the "
"future's result isn't yet available, raises :exc:`InvalidStateError`. If the"
" future is done and has an exception set, this exception is raised."
msgstr ""
"フューチャがキャンセルされていた場合 :exc:`CancelledError` が送出されます。フューチャの結果がまだ利用できない場合 "
":exc:`InvalidStateError` が送出されます。フューチャが終了し例外の集合を持っていた場合その例外が送出されます。"

#: ../../library/asyncio-task.rst:271
msgid "Return the exception that was set on this future."
msgstr "このフューチャで設定された例外を返します。"

#: ../../library/asyncio-task.rst:273
msgid ""
"The exception (or ``None`` if no exception was set) is returned only if the "
"future is done. If the future has been cancelled, raises "
":exc:`CancelledError`. If the future isn't done yet, raises "
":exc:`InvalidStateError`."
msgstr ""
"例外 (例外が設定されていない場合は ``None``) はフューチャが終了した場合のみ返されます。フューチャがキャンセルされていた場合 "
":exc:`CancelledError` が送出されます。フューチャがまだ終了していない場合 :exc:`InvalidStateError` "
"が送出されます。"

#: ../../library/asyncio-task.rst:280
msgid "Add a callback to be run when the future becomes done."
msgstr "フューチャが終了したときに実行するコールバックを追加します。"

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

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

#: ../../library/asyncio-task.rst:290
msgid ""
":ref:`Use functools.partial to pass parameters to the callback <asyncio-"
"pass-keywords>`. For example, "
"``fut.add_done_callback(functools.partial(print, \"Future:\", flush=True))``"
" will call ``print(\"Future:\", fut, flush=True)``."
msgstr ""
":ref:`引数をコールバックに渡すには functools.partial を使います <asyncio-pass-keywords>`。例えば "
"``fut.add_done_callback(functools.partial(print, \"Future:\", flush=True))``"
" は ``print(\"Future:\", fut, flush=True)`` を呼びます。"

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

#: ../../library/asyncio-task.rst:301
msgid "Remove all instances of a callback from the \"call when done\" list."
msgstr "\"終了時に呼び出す\" リストからコールバックのすべてのインスタンスを除去します。"

#: ../../library/asyncio-task.rst:303
msgid "Returns the number of callbacks removed."
msgstr "除去されたコールバック数を返します。"

#: ../../library/asyncio-task.rst:307
msgid "Mark the future done and set its result."
msgstr "フューチャの終了をマークしその結果を設定します。"

#: ../../library/asyncio-task.rst:309 ../../library/asyncio-task.rst:316
msgid ""
"If the future is already done when this method is called, raises "
":exc:`InvalidStateError`."
msgstr "このメソッドが呼ばれたときにフューチャがすでに終了している場合、:exc:`InvalidStateError` を送出します。"

#: ../../library/asyncio-task.rst:314
msgid "Mark the future done and set an exception."
msgstr "フューチャの終了をマークし例外を設定します。"

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

#: ../../library/asyncio-task.rst:327
msgid "Example: Future with run_until_complete()"
msgstr "例: run_until_complete() を使ったフューチャ"

#: ../../library/asyncio-task.rst:329
msgid ""
"Example combining a :class:`Future` and a :ref:`coroutine function "
"<coroutine>`::"
msgstr ":class:`Future` と :ref:`コルーチン関数 <coroutine>` を組み合わせた例::"

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

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

#: ../../library/asyncio-task.rst:357
msgid "Example: Future with run_forever()"
msgstr "例: run_forever() を使ったフューチャ"

#: ../../library/asyncio-task.rst:359
msgid ""
"The previous example can be written differently using the "
":meth:`Future.add_done_callback` method to describe explicitly the control "
"flow::"
msgstr "上の例を :meth:`Future.add_done_callback` メソッド使って制御フローを明示して書くこともできます::"

#: ../../library/asyncio-task.rst:382
msgid ""
"In this example, the future is used to link ``slow_operation()`` to "
"``got_result()``: when ``slow_operation()`` is done, ``got_result()`` is "
"called with the result."
msgstr ""
"この例では ``slow_operation()`` を ``got_result()`` にリンクするために future "
"を用いています。``slow_operation()`` が終了したとき ``got_result()`` が結果と供に呼ばれます。"

#: ../../library/asyncio-task.rst:388
msgid "Task"
msgstr "タスク"

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

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

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

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

#: ../../library/asyncio-task.rst:412
msgid ""
"Event loops use cooperative scheduling: an event loop only runs one task at "
"a time. Other tasks may run in parallel if other event loops are running in "
"different threads. While a task waits for the completion of a future, the "
"event loop executes a new task."
msgstr ""
"イベントループは協調スケジューリングを使用します: 1 つのイベントループは同時に 1 "
"つのタスクのみ実行します。その他のタスクは、他のイベントループが異なるメソッドで実行されている場合に並列で実行されるかもしれません。タスクがフューチャの計算を待っている間、イベントループは新しいタスクを実行します。"

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

#: ../../library/asyncio-task.rst:425
msgid ""
"If a pending task is destroyed, the execution of its wrapped :ref:`coroutine"
" <coroutine>` did not complete. It is probably a bug and a warning is "
"logged: see :ref:`Pending task destroyed <asyncio-pending-task-destroyed>`."
msgstr ""
"未完のタスクが破棄された場合、それのラップされた :ref:`コルーチン <coroutine>` "
"は完了しません。これはおそらくバグであり警告がログに記録されます: :ref:`未完のタスクの破棄 <asyncio-pending-task-"
"destroyed>` を参照してください。"

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

#: ../../library/asyncio-task.rst:432
msgid ""
"Tasks support the :mod:`contextvars` module.  When a Task is created it "
"copies the current context and later runs its coroutine in the copied "
"context.  See :pep:`567` for more details."
msgstr ""

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

#: ../../library/asyncio-task.rst:443
msgid "Return a set of all tasks for an event loop."
msgstr "イベントループ *loop* のすべてのタスクの集合を返します。"

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

#: ../../library/asyncio-task.rst:451
msgid "Return the currently running task in an event loop or ``None``."
msgstr "イベントループ内で現在実行中のタスクまたは ``None`` を返します。"

#: ../../library/asyncio-task.rst:453
msgid "By default the current task for the current event loop is returned."
msgstr "デフォルトでは現在のイベントループの現在のタスクが返されます。"

#: ../../library/asyncio-task.rst:455
msgid ""
"``None`` is returned when called not in the context of a :class:`Task`."
msgstr ":class:`Task` のコンテキスト内から呼び出されたのではない場合 ``None`` が返されます。"

#: ../../library/asyncio-task.rst:459
msgid "Request that this task cancel itself."
msgstr "このタスクのキャンセルを自身で要求します。"

#: ../../library/asyncio-task.rst:461
msgid ""
"This arranges for a :exc:`~concurrent.futures.CancelledError` to be thrown "
"into the wrapped coroutine on the next cycle through the event loop. The "
"coroutine then has a chance to clean up or even deny the request using "
"try/except/finally."
msgstr ""
"これは、イベントループを通して次のサイクルにおいてラップされたコルーチンに投入される "
":exc:`~concurrent.futures.CancelledError` を準備します。コルーチンにはその後 "
"try/except/finally を使用してクリーンアップするか要求を拒否する機会が与えられます。"

#: ../../library/asyncio-task.rst:466
msgid ""
"Unlike :meth:`Future.cancel`, this does not guarantee that the task will be "
"cancelled: the exception might be caught and acted upon, delaying "
"cancellation of the task or preventing cancellation completely. The task may"
" also return a value or raise a different exception."
msgstr ""
":meth:`Future.cancel` と異なり、これはタスクのキャンセルを保証しません: "
"例外が補足されそれが処理されることで、タスクのキャンセル処理が遅延したりキャンセル処理が完了しない場合があります。また、タスクは戻り値を返すか異なる例外を送出する場合もあります。"

#: ../../library/asyncio-task.rst:471
msgid ""
"Immediately after this method is called, :meth:`~Future.cancelled` will not "
"return ``True`` (unless the task was already cancelled). A task will be "
"marked as cancelled when the wrapped coroutine terminates with a "
":exc:`~concurrent.futures.CancelledError` exception (even if :meth:`cancel` "
"was not called)."
msgstr ""
"このメソッドが呼び出された直後は :meth:`~Future.cancelled` は ``True`` を返しません "
"(タスクがすでにキャンセル済みの場合は除く)。ラップされたコルーチンが "
":exc:`~concurrent.futures.CancelledError` で中止されたとき、タスクは (:meth:`cancel` "
"が呼ばれなかった場合でも) キャンセル済みとマークされます。"

#: ../../library/asyncio-task.rst:479
msgid "Return the list of stack frames for this task's coroutine."
msgstr "このタスクのコルーチンのスタックフレームのリストを返します。"

#: ../../library/asyncio-task.rst:481
msgid ""
"If the coroutine is not done, this returns the stack where it is suspended."
"  If the coroutine has completed successfully or was cancelled, this returns"
" an empty list.  If the coroutine was terminated by an exception, this "
"returns the list of traceback frames."
msgstr ""

#: ../../library/asyncio-task.rst:487
msgid "The frames are always ordered from oldest to newest."
msgstr "フレームは常に古いものから新しい物へ並んでいます。"

#: ../../library/asyncio-task.rst:489
msgid ""
"The optional limit gives the maximum number of frames to return; by default "
"all available frames are returned.  Its meaning differs depending on whether"
" a stack or a traceback is returned: the newest frames of a stack are "
"returned, but the oldest frames of a traceback are returned. (This matches "
"the behavior of the traceback module.)"
msgstr ""
"任意の引数 *limit* には返すフレームの最大数を指定します; "
"デフォルトでは有効なすべてのフレームが返されます。これは返される値がスタックかトレースバックかによって意味が変わります: "
"スタックでは最新のフレームから返されますが、トレースバックでは最古のものから返されます。 (これは traceback "
"モジュールの振る舞いと一致します。)"

#: ../../library/asyncio-task.rst:495
msgid ""
"For reasons beyond our control, only one stack frame is returned for a "
"suspended coroutine."
msgstr "いかんともしがたい理由により、サスペンドされているコルーチンの場合スタックフレームが 1 個だけ返されます。"

#: ../../library/asyncio-task.rst:500
msgid "Print the stack or traceback for this task's coroutine."
msgstr "このタスクのコルーチンのスタックあるいはトレースバックを出力します。"

#: ../../library/asyncio-task.rst:502
msgid ""
"This produces output similar to that of the traceback module, for the frames"
" retrieved by get_stack().  The limit argument is passed to get_stack().  "
"The file argument is an I/O stream to which the output is written; by "
"default output is written to sys.stderr."
msgstr ""
"この出力は get_stack() によって回収されたフレームで、traceback モジュールのそれと同じです。引数 *limit* は "
"get_stack() に渡されます。引数 *file* は出力を書き込む I/O ストリームです; デフォルトでは ``sys.stderr`` "
"になります。"

#: ../../library/asyncio-task.rst:509
msgid "Example: Parallel execution of tasks"
msgstr "例: タスクの並列実行"

#: ../../library/asyncio-task.rst:511
msgid "Example executing 3 tasks (A, B, C) in parallel::"
msgstr "3 個のタスク (A, B, C) を並列に実行する例です::"

#: ../../library/asyncio-task.rst:531
msgid "Output::"
msgstr "出力::"

#: ../../library/asyncio-task.rst:543
msgid ""
"A task is automatically scheduled for execution when it is created. The "
"event loop stops when all tasks are done."
msgstr "タスクは作成されたときに実行を自動的にスケジュールされます。イベントループはすべてのタスクが終了したときに停止します。"

#: ../../library/asyncio-task.rst:548
msgid "Task functions"
msgstr "タスク関数"

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

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

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

#: ../../library/asyncio-task.rst:570
msgid "Return a set of :class:`Task` objects created for the loop."
msgstr ""

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

#: ../../library/asyncio-task.rst:581
msgid ""
"Return an iterator whose values, when waited for, are :class:`Future` "
"instances."
msgstr "その値のイテレーターか、待機中のときは :class:`Future` インスタンスを返します。"

#: ../../library/asyncio-task.rst:584
msgid ""
"Raises :exc:`asyncio.TimeoutError` if the timeout occurs before all Futures "
"are done."
msgstr "全フューチャが終了する前にタイムアウトが発生した場合 :exc:`asyncio.TimeoutError` を送出します。"

#: ../../library/asyncio-task.rst:587
msgid "Example::"
msgstr "以下はプログラム例です::"

#: ../../library/asyncio-task.rst:595
msgid "The futures ``f`` are not necessarily members of fs."
msgstr "フューチャ ``f`` は fs のメンバーである必要はありません。"

#: ../../library/asyncio-task.rst:599
msgid ""
"Schedule the execution of a :ref:`coroutine object <coroutine>`: wrap it in "
"a future. Return a :class:`Task` object."
msgstr ""
":ref:`コルーチンオブジェクト <coroutine>` の実行をスケジュールします: このときフューチャにラップします。:class:`Task`"
" オブジェクトを返します。"

#: ../../library/asyncio-task.rst:602
msgid "If the argument is a :class:`Future`, it is returned directly."
msgstr "引数が :class:`Future` の場合、それが直接返されます。"

#: ../../library/asyncio-task.rst:606
msgid "The function accepts any :term:`awaitable` object."
msgstr ""

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

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

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

#: ../../library/asyncio-task.rst:626
msgid ""
"Return a future aggregating results from the given coroutine objects or "
"futures."
msgstr "与えられたコルーチンオブジェクトあるいはフューチャからの結果を一つにまとめたフューチャを返します。"

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

#: ../../library/asyncio-task.rst:637
msgid ""
"Cancellation: if the outer Future is cancelled, all children (that have not "
"completed yet) are also cancelled.  If any child is cancelled, this is "
"treated as if it raised :exc:`~concurrent.futures.CancelledError` -- the "
"outer Future is *not* cancelled in this case.  (This is to prevent the "
"cancellation of one child to cause other children to be cancelled.)"
msgstr ""
"キャンセル: 外側のフューチャがキャンセルされた場合、すべての (まだ完了していない) "
"子プロセスもキャンセルされます。いずれかの子プロセスがキャンセルされた場合、これは "
":exc:`~concurrent.futures.CancelledError` を送出するように扱います -- この場合外側のフューチャはキャンセル"
" *されません*。 (This is to prevent the cancellation of one child to cause other "
"children to be cancelled.)"

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

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

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

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

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

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

#: ../../library/asyncio-task.rst:674
msgid ""
"If an exception is raised in the coroutine, the returned future will be "
"notified. It can also be used to cancel the task in the event loop::"
msgstr ""

#: ../../library/asyncio-task.rst:687
msgid ""
"See the :ref:`concurrency and multithreading <asyncio-multithreading>` "
"section of the documentation."
msgstr "このドキュメントの :ref:`asyncio-multithreading` 節を参照してください。"

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

#: ../../library/asyncio-task.rst:700
msgid ""
"Create a :ref:`coroutine <coroutine>` that completes after a given time (in "
"seconds).  If *result* is provided, it is produced to the caller when the "
"coroutine completes."
msgstr ""
"与えられた時間 (秒) 後に完了する :ref:`コルーチン <coroutine>` を作成します。*result* "
"が与えられた場合、コルーチン完了時にそれが呼び出し元に返されます。"

#: ../../library/asyncio-task.rst:704
msgid ""
"The resolution of the sleep depends on the :ref:`granularity of the event "
"loop <asyncio-delayed-calls>`."
msgstr "スリープの分解能は :ref:`イベントループの粒度 <asyncio-delayed-calls>` に依存します。"

#: ../../library/asyncio-task.rst:707 ../../library/asyncio-task.rst:774
msgid "This function is a :ref:`coroutine <coroutine>`."
msgstr "この関数は :ref:`コルーチン <coroutine>` です。"

#: ../../library/asyncio-task.rst:711
msgid "Wait for a future, shielding it from cancellation."
msgstr "フューチャを待機しキャンセル処理から保護します。"

#: ../../library/asyncio-task.rst:713
msgid "The statement::"
msgstr "命令文::"

#: ../../library/asyncio-task.rst:717
msgid "is exactly equivalent to the statement::"
msgstr "上の文は以下と完全に等価です::"

#: ../../library/asyncio-task.rst:721
msgid ""
"*except* that if the coroutine containing it is cancelled, the task running "
"in ``something()`` is not cancelled.  From the point of view of "
"``something()``, the cancellation did not happen.  But its caller is still "
"cancelled, so the yield-from expression still raises "
":exc:`~concurrent.futures.CancelledError`.  Note: If ``something()`` is "
"cancelled by other means this will still cancel ``shield()``."
msgstr ""
"それを含むコルーチンがキャンセルされた場合を *除き*、``something()`` "
"内で動作するタスクはキャンセルされません。``something()`` "
"側から見るとキャンセル処理は発生しません。ただし、呼び出し元がキャンセルされた場合は、yield-from 表現は "
":exc:`~concurrent.futures.CancelledError` を送出します。注意: ``something()`` "
"が他の理由でキャンセルされた場合は ``shield()`` でも保護できません。"

#: ../../library/asyncio-task.rst:728
msgid ""
"If you want to completely ignore cancellation (not recommended) you can "
"combine ``shield()`` with a try/except clause, as follows::"
msgstr ""
"完全にキャンセル処理を無視させたい場合 (推奨はしません) は、以下のように ``shield()`` と try/except "
"節の組み合わせで行うことができます::"

#: ../../library/asyncio-task.rst:740
msgid ""
"Wait for the Futures and coroutine objects given by the sequence *futures* "
"to complete.  Coroutines will be wrapped in Tasks. Returns two sets of "
":class:`Future`: (done, pending)."
msgstr ""
"シーケンス *futures* で与えられたフューチャおよびコルーチンオブジェクトが完了するまで待機します。コルーチンはタスクでラップされます。戻り値は"
" (完了した :class:`Future`, 未完の :class:`Future`) の 2 個の集合になります。"

#: ../../library/asyncio-task.rst:744
msgid "The sequence *futures* must not be empty."
msgstr "シーケンス *futures* は空であってはなりません。"

#: ../../library/asyncio-task.rst:746
msgid ""
"*timeout* can be used to control the maximum number of seconds to wait "
"before returning.  *timeout* can be an int or float.  If *timeout* is not "
"specified or ``None``, there is no limit to the wait time."
msgstr ""
"*timeout* で結果を返すまで待機する最大秒数を指定できます。*timeout* は整数か浮動小数点数をとります。*timeout* "
"が指定されないか ``None`` の場合、無期限に待機します。"

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

#: ../../library/asyncio-task.rst:756
msgid "Constant"
msgstr "定数"

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

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

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

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

#: ../../library/asyncio-task.rst:761
msgid ""
"The function will return when any future finishes by raising an exception.  "
"If no future raises an exception then it is equivalent to "
":const:`ALL_COMPLETED`."
msgstr ""
"いずれかのフューチャが例外の送出で終了した場合に返します。例外を送出したフューチャがない場合は、:const:`ALL_COMPLETED` "
"と等価になります。"

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

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

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

#: ../../library/asyncio-task.rst:776
msgid "Usage::"
msgstr "使い方::"

#: ../../library/asyncio-task.rst:782
msgid ""
"This does not raise :exc:`asyncio.TimeoutError`! Futures that aren't done "
"when the timeout occurs are returned in the second set."
msgstr ""
"これは :exc:`asyncio.TimeoutError` "
"を送出しません。タイムアウトが発生して完了しなかったフューチャは戻り値の後者の集合に含まれます。"

#: ../../library/asyncio-task.rst:788
msgid ""
"Wait for the single :class:`Future` or :ref:`coroutine object <coroutine>` "
"to complete with timeout. If *timeout* is ``None``, block until the future "
"completes."
msgstr ""
"単一の :class:`Future` または :ref:`コルーチンオブジェクト <coroutine>` を期限付きで待機します。*timeout*"
" が ``None`` の場合、フューチャが完了するまでブロックします。"

#: ../../library/asyncio-task.rst:792
msgid "Coroutine will be wrapped in :class:`Task`."
msgstr "コルーチンは :class:`Task` でラップされます。"

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

#: ../../library/asyncio-task.rst:800
msgid "If the wait is cancelled, the future *fut* is also cancelled."
msgstr "待機が中止された場合 *fut* も中止されます。"

#: ../../library/asyncio-task.rst:802
msgid "This function is a :ref:`coroutine <coroutine>`, usage::"
msgstr "この関数は :ref:`コルーチン <coroutine>` です。使用法::"

#: ../../library/asyncio-task.rst:806
msgid "If the wait is cancelled, the future *fut* is now also cancelled."
msgstr "待機が中止された場合 *fut* も中止されます。"

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