asyncio-task.po

# 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:
# tomo, 2020
# Atsuo Ishimoto <atsuoishimoto@gmail.com>, 2021
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.8\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 16:06+0000\n"
"PO-Revision-Date: 2020-05-30 11:56+0000\n"
"Last-Translator: Atsuo Ishimoto <atsuoishimoto@gmail.com>, 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/asyncio-task.rst:6
msgid "Coroutines and Tasks"
msgstr "コルーチンと Task"

#: ../../library/asyncio-task.rst:8
msgid ""
"This section outlines high-level asyncio APIs to work with coroutines and "
"Tasks."
msgstr ""
"この節では、コルーチンと Task を利用する高レベルの asyncio の API の概略を解"
"説します。"

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

#: ../../library/asyncio-task.rst:21
msgid ""
":term:`Coroutines <coroutine>` declared with the async/await syntax is the "
"preferred way of writing asyncio applications.  For example, the following "
"snippet of code (requires Python 3.7+) prints \"hello\", waits 1 second, and "
"then prints \"world\"::"
msgstr ""
"async/await 構文で宣言された :term:`コルーチン <coroutine>` は、 asyncio を"
"使ったアプリケーションを書くのに推奨される方法です。例えば、次のコードスニ"
"ペット (Python 3.7 以降が必要) は \"hello\" を出力し、そこから 1 秒待って "
"\"world\" を出力します:: "

#: ../../library/asyncio-task.rst:37
msgid ""
"Note that simply calling a coroutine will not schedule it to be executed::"
msgstr ""
"単にコルーチンを呼び出しただけでは、コルーチンの実行スケジュールは予約されて"
"いないことに注意してください::"

#: ../../library/asyncio-task.rst:43
msgid "To actually run a coroutine, asyncio provides three main mechanisms:"
msgstr ""
"実際にコルーチンを走らせるために、 asyncio は3つの機構を提供しています:"

#: ../../library/asyncio-task.rst:45
msgid ""
"The :func:`asyncio.run` function to run the top-level entry point \"main()\" "
"function (see the above example.)"
msgstr ""
"最上位のエントリーポイントである \"main()\" 関数を実行する :func:`asyncio."
"run` 関数 (上の例を参照してください。)"

#: ../../library/asyncio-task.rst:48
msgid ""
"Awaiting on a coroutine.  The following snippet of code will print \"hello\" "
"after waiting for 1 second, and then print \"world\" after waiting for "
"*another* 2 seconds::"
msgstr ""
"コルーチンを await すること。次のコード片は 1 秒間待機した後に \"hello\" と出"
"力し、 *更に* 2 秒間待機してから \"world\" と出力します::"

#: ../../library/asyncio-task.rst:69
msgid "Expected output::"
msgstr "予想される出力::"

#: ../../library/asyncio-task.rst:76
msgid ""
"The :func:`asyncio.create_task` function to run coroutines concurrently as "
"asyncio :class:`Tasks <Task>`."
msgstr ""
"asyncio の :class:`Tasks <Task>` としてコルーチンを並行して走らせる :func:"
"`asyncio.create_task` 関数。"

#: ../../library/asyncio-task.rst:79
msgid ""
"Let's modify the above example and run two ``say_after`` coroutines "
"*concurrently*::"
msgstr ""
"上のコード例を編集して、ふたつの ``say_after`` コルーチンを *並行して* 走らせ"
"てみましょう::"

#: ../../library/asyncio-task.rst:98
msgid ""
"Note that expected output now shows that the snippet runs 1 second faster "
"than before::"
msgstr ""
"予想される出力が、スニペットの実行が前回よりも 1 秒早いことを示していることに"
"注意してください::"

#: ../../library/asyncio-task.rst:110
msgid "Awaitables"
msgstr "Awaitable"

#: ../../library/asyncio-task.rst:112
msgid ""
"We say that an object is an **awaitable** object if it can be used in an :"
"keyword:`await` expression.  Many asyncio APIs are designed to accept "
"awaitables."
msgstr ""
"あるオブジェクトを :keyword:`await` 式の中で使うことができる場合、そのオブ"
"ジェクトを **awaitable** オブジェクトと言います。多くの asyncio API は "
"awaitable を受け取るように設計されています。"

#: ../../library/asyncio-task.rst:116
msgid ""
"There are three main types of *awaitable* objects: **coroutines**, "
"**Tasks**, and **Futures**."
msgstr ""
"*awaitable* オブジェクトには主に3つの種類があります: **コルーチン**, "
"**Task**, そして **Future** です"

#: ../../library/asyncio-task.rst:122
msgid ""
"Python coroutines are *awaitables* and therefore can be awaited from other "
"coroutines::"
msgstr ""
"Python のコルーチンは *awaitable* であり、そのため他のコルーチンを待機させら"
"れます::"

#: ../../library/asyncio-task.rst:143
msgid ""
"In this documentation the term \"coroutine\" can be used for two closely "
"related concepts:"
msgstr ""
"このドキュメントにおいて「コルーチン」という用語は以下2つの密接に関連した概念"
"に対して使用できます:"

#: ../../library/asyncio-task.rst:146
msgid "a *coroutine function*: an :keyword:`async def` function;"
msgstr "*コルーチン関数*: :keyword:`async def` 関数;"

#: ../../library/asyncio-task.rst:148
msgid ""
"a *coroutine object*: an object returned by calling a *coroutine function*."
msgstr ""
"*コルーチンオブジェクト*: *コルーチン関数* を呼び出すと返ってくるオブジェク"
"ト."

#: ../../library/asyncio-task.rst:151
msgid ""
"asyncio also supports legacy :ref:`generator-based "
"<asyncio_generator_based_coro>` coroutines."
msgstr ""
"asyncio は、古くからある :ref:`ジェネレータベース "
"<asyncio_generator_based_coro>` のコルーチンもサポートしています。"

#: ../../library/asyncio-task.rst:156
msgid "Tasks"
msgstr "Task"

#: ../../library/asyncio-task.rst:157
msgid "*Tasks* are used to schedule coroutines *concurrently*."
msgstr "*Task* は、コルーチンを *並行に* スケジュールするのに使います。"

#: ../../library/asyncio-task.rst:159
msgid ""
"When a coroutine is wrapped into a *Task* with functions like :func:`asyncio."
"create_task` the coroutine is automatically scheduled to run soon::"
msgstr ""
":func:`asyncio.create_task` のような関数で、コルーチンが *Task* にラップされ"
"ているとき、自動的にコルーチンは即時実行されるようにスケジュールされます::"

#: ../../library/asyncio-task.rst:181
msgid "Futures"
msgstr "Future"

#: ../../library/asyncio-task.rst:182
msgid ""
"A :class:`Future` is a special **low-level** awaitable object that "
"represents an **eventual result** of an asynchronous operation."
msgstr ""
":class:`Future` は、非同期処理の **最終結果** を表現する特別な **低レベルの"
"** awaitable オブジェクトです。"

#: ../../library/asyncio-task.rst:185
msgid ""
"When a Future object is *awaited* it means that the coroutine will wait "
"until the Future is resolved in some other place."
msgstr ""
"Future オブジェクトが他の awaitable を *待機させている* と言うときは、ある場"
"所で Future が解決されるまでコルーチンが待機するということです。"

#: ../../library/asyncio-task.rst:188
msgid ""
"Future objects in asyncio are needed to allow callback-based code to be used "
"with async/await."
msgstr ""
"asyncioのFutureオブジェクトを使うと、async/awaitとコールバック形式のコードを"
"併用できます。"

#: ../../library/asyncio-task.rst:191
msgid ""
"Normally **there is no need** to create Future objects at the application "
"level code."
msgstr ""
"通常、アプリケーション水準のコードで Future オブジェクトを作る **必要はありま"
"せん** 。"

#: ../../library/asyncio-task.rst:194
msgid ""
"Future objects, sometimes exposed by libraries and some asyncio APIs, can be "
"awaited::"
msgstr ""
"Future オブジェクトはライブラリや asyncio の API で表に出ることもあり、他の "
"awaitable を待機させられます::"

#: ../../library/asyncio-task.rst:206
msgid ""
"A good example of a low-level function that returns a Future object is :meth:"
"`loop.run_in_executor`."
msgstr ""
"Future オブジェクトを返す低レベル関数の良い例は :meth:`loop.run_in_executor` "
"です。"

#: ../../library/asyncio-task.rst:211
msgid "Running an asyncio Program"
msgstr "非同期プログラムの実行"

#: ../../library/asyncio-task.rst:215
msgid "Execute the :term:`coroutine` *coro* and return the result."
msgstr ":term:`coroutine` *coro* を実行し、結果を返します。"

#: ../../library/asyncio-task.rst:217
msgid ""
"This function runs the passed coroutine, taking care of managing the asyncio "
"event loop and *finalizing asynchronous generators*."
msgstr ""
"この関数は、非同期イベントループの管理と *非同期ジェネレータの終了処理* を行"
"いながら、渡されたコルーチンを実行します。"

#: ../../library/asyncio-task.rst:221
msgid ""
"This function cannot be called when another asyncio event loop is running in "
"the same thread."
msgstr ""
"この関数は、同じスレッドで他の非同期イベントループが実行中のときは呼び出せま"
"せん。"

#: ../../library/asyncio-task.rst:224
msgid "If *debug* is ``True``, the event loop will be run in debug mode."
msgstr ""
"*debug* が ``True`` の場合、イベントループはデバッグモードで実行されます。"

#: ../../library/asyncio-task.rst:226
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 ""
"この関数は常に新しいイベントループを作成し、終了したらそのイベントループを閉"
"じます。\n"
"この関数は非同期プログラムのメインのエントリーポイントとして使われるべきで、"
"理想的には 1 回だけ呼び出されるべきです。"

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

#: ../../library/asyncio-task.rst:242
msgid ""
"The source code for ``asyncio.run()`` can be found in :source:`Lib/asyncio/"
"runners.py`."
msgstr ""
"``asyncio.run()`` のソースコードは :source:`Lib/asyncio/runners.py` にありま"
"す。"

#: ../../library/asyncio-task.rst:246
msgid "Creating Tasks"
msgstr "Task の作成"

#: ../../library/asyncio-task.rst:250
msgid ""
"Wrap the *coro* :ref:`coroutine <coroutine>` into a :class:`Task` and "
"schedule its execution.  Return the Task object."
msgstr ""
"*coro* :ref:`coroutine <coroutine>` を :class:`Task` でラップし、その実行をス"
"ケジュールします。\n"
"Task オブジェクトを返します。"

#: ../../library/asyncio-task.rst:253
msgid ""
"If *name* is not ``None``, it is set as the name of the task using :meth:"
"`Task.set_name`."
msgstr ""
"もし *name* が ``None`` でない場合、:meth:`Task.set_name` を使用し、*name* が"
"タスクの名前として設定されます。"

#: ../../library/asyncio-task.rst:256
msgid ""
"The task is executed in the loop returned by :func:`get_running_loop`, :exc:"
"`RuntimeError` is raised if there is no running loop in current thread."
msgstr ""
"その Task オブジェクトは :func:`get_running_loop` から返されたループの中で実"
"行されます。現在のスレッドに実行中のループが無い場合は、 :exc:`RuntimeError` "
"が送出されます。"

#: ../../library/asyncio-task.rst:260
msgid ""
"This function has been **added in Python 3.7**.  Prior to Python 3.7, the "
"low-level :func:`asyncio.ensure_future` function can be used instead::"
msgstr ""
"この関数は **Python 3.7 で追加** されました。\n"
"Python 3.7 より前では、代わりに低レベルの :func:`asyncio.ensure_future` 関数"
"が使えます::"

#: ../../library/asyncio-task.rst:277 ../../library/asyncio-task.rst:724
msgid "Added the ``name`` parameter."
msgstr "``name`` パラメータが追加されました。"

#: ../../library/asyncio-task.rst:282
msgid "Sleeping"
msgstr "スリープ"

#: ../../library/asyncio-task.rst:286
msgid "Block for *delay* seconds."
msgstr "*delay* 秒だけ停止します。"

#: ../../library/asyncio-task.rst:288
msgid ""
"If *result* is provided, it is returned to the caller when the coroutine "
"completes."
msgstr ""
"*result* が提供されている場合は、コルーチン完了時にそれが呼び出し元に返されま"
"す。"

#: ../../library/asyncio-task.rst:291
msgid ""
"``sleep()`` always suspends the current task, allowing other tasks to run."
msgstr ""
"``sleep()`` は常に現在の Task を一時中断し、他の Task が実行されるのを許可し"
"ます。"

#: ../../library/asyncio-task.rst:296 ../../library/asyncio-task.rst:351
#: ../../library/asyncio-task.rst:438 ../../library/asyncio-task.rst:468
#: ../../library/asyncio-task.rst:553 ../../library/asyncio-task.rst:600
#: ../../library/asyncio-task.rst:729
msgid "The *loop* parameter."
msgstr "*loop* パラメータ。"

#: ../../library/asyncio-task.rst:299
msgid ""
"Example of coroutine displaying the current date every second for 5 seconds::"
msgstr "現在の時刻を5秒間、毎秒表示するコルーチンの例::"

#: ../../library/asyncio-task.rst:318
msgid "Running Tasks Concurrently"
msgstr "並行な Task 実行"

#: ../../library/asyncio-task.rst:322
msgid ""
"Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws* sequence "
"*concurrently*."
msgstr ""
"*aws* シーケンスにある :ref:`awaitable オブジェクト <asyncio-awaitables>` を "
"*並行* 実行します。"

#: ../../library/asyncio-task.rst:325
msgid ""
"If any awaitable in *aws* is a coroutine, it is automatically scheduled as a "
"Task."
msgstr ""
"*aws* にある awaitable がコルーチンである場合、自動的に Task としてスケジュー"
"ルされます。"

#: ../../library/asyncio-task.rst:328
msgid ""
"If all awaitables are completed successfully, the result is an aggregate "
"list of returned values.  The order of result values corresponds to the "
"order of awaitables in *aws*."
msgstr ""
"全ての awaitable が正常終了した場合、その結果は返り値を集めたリストになりま"
"す。\n"
"返り値の順序は、 *aws* での awaitable の順序に相当します。"

#: ../../library/asyncio-task.rst:332
msgid ""
"If *return_exceptions* is ``False`` (default), the first raised exception is "
"immediately propagated to the task that awaits on ``gather()``.  Other "
"awaitables in the *aws* sequence **won't be cancelled** and will continue to "
"run."
msgstr ""
"*return_exceptions* が ``False`` である場合(デフォルト)、``gather()`` で "
"await しているタスクに対して、最初の例外が直接伝えられます。*aws* に並んでい"
"る他の awaitable は、**キャンセルされずに** 引き続いて実行されます。"

#: ../../library/asyncio-task.rst:337
msgid ""
"If *return_exceptions* is ``True``, exceptions are treated the same as "
"successful results, and aggregated in the result list."
msgstr ""
"*return_exceptions* が ``True`` だった場合、例外は成功した結果と同じように取"
"り扱われ、結果リストに集められます。"

#: ../../library/asyncio-task.rst:340
msgid ""
"If ``gather()`` is *cancelled*, all submitted awaitables (that have not "
"completed yet) are also *cancelled*."
msgstr ""
"``gather()`` が *キャンセル* された場合、起動された全ての (未完了の) "
"awaitable も *キャンセル* されます。"

#: ../../library/asyncio-task.rst:343
msgid ""
"If any Task or Future from the *aws* sequence is *cancelled*, it is treated "
"as if it raised :exc:`CancelledError` -- the ``gather()`` call is **not** "
"cancelled in this case.  This is to prevent the cancellation of one "
"submitted Task/Future to cause other Tasks/Futures to be cancelled."
msgstr ""
"*aws* シーケンスにある Task あるいは Future が *キャンセル* された場合、 :"
"exc:`CancelledError` を送出したかのうように扱われます。つまり、この場合 "
"``gather()`` 呼び出しはキャンセル *されません*。\n"
"これは、起動された 1 つの Task あるいは Future のキャンセルが、他の Task ある"
"いは Future のキャンセルを引き起こすのを避けるためです。"

#: ../../library/asyncio-task.rst:389
msgid ""
"If *return_exceptions* is False, cancelling gather() after it has been "
"marked done won't cancel any submitted awaitables. For instance, gather can "
"be marked done after propagating an exception to the caller, therefore, "
"calling ``gather.cancel()`` after catching an exception (raised by one of "
"the awaitables) from gather won't cancel any other awaitables."
msgstr ""
"*return_exceptions* が False の場合、いったん完了状態となった gather() をキャ"
"ンセルしても起動された awaitables がキャンセルされないことがあります。例え"
"ば、 gather は例外を呼び出し元に送出したあと完了状態になることがあるため、 "
"(起動した awaitable のいずれかから送出された) gather からの例外をキャッチした"
"後で ``gather.cancel()`` を呼び出しても、他の awaitable がキャンセルされない"
"可能性があります。"

#: ../../library/asyncio-task.rst:396
msgid ""
"If the *gather* itself is cancelled, the cancellation is propagated "
"regardless of *return_exceptions*."
msgstr ""
"*gather* 自身がキャンセルされた場合は、 *return_exceptions* の値に関わらず"
"キャンセルが伝搬されます。"

#: ../../library/asyncio-task.rst:402
msgid "Shielding From Cancellation"
msgstr "キャンセルからの保護"

#: ../../library/asyncio-task.rst:406
msgid ""
"Protect an :ref:`awaitable object <asyncio-awaitables>` from being :meth:"
"`cancelled <Task.cancel>`."
msgstr ""
":meth:`キャンセル <Task.cancel>` から :ref:`awaitable オブジェクト <asyncio-"
"awaitables>` を保護します。"

#: ../../library/asyncio-task.rst:409 ../../library/asyncio-task.rst:449
msgid "If *aw* is a coroutine it is automatically scheduled as a Task."
msgstr ""
"*aw* がコルーチンだった場合、自動的に Task としてスケジュールされます。"

#: ../../library/asyncio-task.rst:411
msgid "The statement::"
msgstr "文::"

#: ../../library/asyncio-task.rst:415
msgid "is equivalent to::"
msgstr "は、以下と同じです ::"

#: ../../library/asyncio-task.rst:419
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. Although its caller is "
"still cancelled, so the \"await\" expression still raises a :exc:"
"`CancelledError`."
msgstr ""
"それを含むコルーチンがキャンセルされた場合を *除き*、``something()`` 内で動作"
"している Task はキャンセルされません。\n"
"``something()`` 側から見るとキャンセルは発生しません。\n"
"呼び出し元がキャンセルされた場合でも、 \"await\" 式は :exc:`CancelledError` "
"を送出します。"

#: ../../library/asyncio-task.rst:425
msgid ""
"If ``something()`` is cancelled by other means (i.e. from within itself) "
"that would also cancel ``shield()``."
msgstr ""
"注意: ``something()`` が他の理由 (例えば、原因が自分自身) でキャンセルされた"
"場合は ``shield()`` でも保護できません。"

#: ../../library/asyncio-task.rst:428
msgid ""
"If it is desired to completely ignore cancellation (not recommended) the "
"``shield()`` function should be combined with a try/except clause, as "
"follows::"
msgstr ""
"完全にキャンセルを無視したい場合 (推奨はしません) は、 ``shield()`` 関数は次"
"のように try/except 節と組み合わせることになるでしょう::"

#: ../../library/asyncio-task.rst:442
msgid "Timeouts"
msgstr "タイムアウト"

#: ../../library/asyncio-task.rst:446
msgid ""
"Wait for the *aw* :ref:`awaitable <asyncio-awaitables>` to complete with a "
"timeout."
msgstr ""
"*aw* :ref:`awaitable <asyncio-awaitables>` が、完了するかタイムアウトになるの"
"を待ちます。"

#: ../../library/asyncio-task.rst:451
msgid ""
"*timeout* can either be ``None`` or a float or int number of seconds to wait "
"for.  If *timeout* is ``None``, block until the future completes."
msgstr ""
"*timeout* には ``None`` もしくは待つ秒数の浮動小数点数か整数を指定できま"
"す。\n"
"*timeout* が ``None`` の場合、 Future が完了するまで待ちます。"

#: ../../library/asyncio-task.rst:455
msgid ""
"If a timeout occurs, it cancels the task and raises :exc:`asyncio."
"TimeoutError`."
msgstr ""
"タイムアウトが起きた場合は、 Task をキャンセルし :exc:`asyncio.TimeoutError` "
"を送出します。"

#: ../../library/asyncio-task.rst:458
msgid ""
"To avoid the task :meth:`cancellation <Task.cancel>`, wrap it in :func:"
"`shield`."
msgstr ""
"Task の :meth:`キャンセル <Task.cancel>` を避けるためには、 :func:`shield` の"
"中にラップしてください。"

#: ../../library/asyncio-task.rst:461
msgid ""
"The function will wait until the future is actually cancelled, so the total "
"wait time may exceed the *timeout*."
msgstr ""
"この関数は、 Future が実際にキャンセルされるまで待つので、全体の待ち時間は "
"*timeout* を超えることもあります。"

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

#: ../../library/asyncio-task.rst:491
msgid ""
"When *aw* is cancelled due to a timeout, ``wait_for`` waits for *aw* to be "
"cancelled.  Previously, it raised :exc:`asyncio.TimeoutError` immediately."
msgstr ""
"*aw* がタイムアウトでキャンセルされたとき、 ``wait_for`` は *aw* がキャンセル"
"されるまで待ちます。\n"
"以前は、すぐに :exc:`asyncio.TimeoutError` を送出していました。"

#: ../../library/asyncio-task.rst:498
msgid "Waiting Primitives"
msgstr "要素の終了待機"

#: ../../library/asyncio-task.rst:503
msgid ""
"Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws* iterable "
"concurrently and block until the condition specified by *return_when*."
msgstr ""

#: ../../library/asyncio-task.rst:507
msgid "Returns two sets of Tasks/Futures: ``(done, pending)``."
msgstr "Task と Future の 2 つ ``(done, pending)`` を返します。"

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

#: ../../library/asyncio-task.rst:513
msgid ""
"*timeout* (a float or int), if specified, can be used to control the maximum "
"number of seconds to wait before returning."
msgstr ""
"*timeout* (浮動小数点数または整数) が指定されていたら、処理を返すのを待つ最大"
"秒数を制御するのに使われます。"

#: ../../library/asyncio-task.rst:516
msgid ""
"Note that this function does not raise :exc:`asyncio.TimeoutError`. Futures "
"or Tasks that aren't done when the timeout occurs are simply returned in the "
"second set."
msgstr ""
"この関数は :exc:`asyncio.TimeoutError` を送出しないことに注意してください。\n"
"タイムアウトが起きたときに完了していなかった Future や Task は、2 つ目の集合"
"の要素として返されるだけです。"

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

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

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

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

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

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

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

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

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

#: ../../library/asyncio-task.rst:541
msgid ""
"Unlike :func:`~asyncio.wait_for`, ``wait()`` does not cancel the futures "
"when a timeout occurs."
msgstr ""
":func:`~asyncio.wait_for` と異なり、  ``wait()`` はタイムアウトが起きたとき"
"に Future をキャンセルしません。"

#: ../../library/asyncio-task.rst:546
msgid ""
"If any awaitable in *aws* is a coroutine, it is automatically scheduled as a "
"Task.  Passing coroutines objects to ``wait()`` directly is deprecated as it "
"leads to :ref:`confusing behavior <asyncio_example_wait_coroutine>`."
msgstr ""
"*aws* にある awaitable のどれかがコルーチンの場合、自動的に Task としてスケ"
"ジュールされます。\n"
"コルーチンオブジェクトを ``wait()`` に直接渡すのは :ref:`紛らわしい振る舞い "
"<asyncio_example_wait_coroutine>` を引き起こすため非推奨です。"

#: ../../library/asyncio-task.rst:558
msgid ""
"``wait()`` schedules coroutines as Tasks automatically and later returns "
"those implicitly created Task objects in ``(done, pending)`` sets.  "
"Therefore the following code won't work as expected::"
msgstr ""
"``wait()`` は自動的にコルーチンを Task としてスケジュールし、その後、暗黙的に"
"作成された Task オブジェクトを組になった集合 ``(done, pending)`` に入れて返し"
"ます。\n"
"従って、次のコードは予想した通りには動作しません::"

#: ../../library/asyncio-task.rst:571
msgid "Here is how the above snippet can be fixed::"
msgstr "上のスクリプト片は次のように修正できます::"

#: ../../library/asyncio-task.rst:584
msgid "Passing coroutine objects to ``wait()`` directly is deprecated."
msgstr "``wait()`` にコルーチンオブジェクトを直接渡すのは非推奨です。"

#: ../../library/asyncio-task.rst:590
msgid ""
"Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws* iterable "
"concurrently.  Return an iterator of coroutines. Each coroutine returned can "
"be awaited to get the earliest next result from the iterable of the "
"remaining awaitables."
msgstr ""
"イテラブル *aws* 内の :ref:`awaitable オブジェクト <asyncio-awaitables>` を並"
"列実行します。コルーチンのイテレータを返します。戻り値の各コルーチンは、残り"
"の awaitable のうちで最も早く得られた結果を待ち受けることができます。"

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

#: ../../library/asyncio-task.rst:609
msgid "Scheduling From Other Threads"
msgstr "外部スレッドからのスケジュール"

#: ../../library/asyncio-task.rst:613
msgid "Submit a coroutine to the given event loop.  Thread-safe."
msgstr ""
"与えられたイベントループにコルーチンを送ります。\n"
"この処理は、スレッドセーフです。"

#: ../../library/asyncio-task.rst:615
msgid ""
"Return a :class:`concurrent.futures.Future` to wait for the result from "
"another OS thread."
msgstr ""
"他の OS スレッドから結果を待つための :class:`concurrent.futures.Future` を返"
"します。"

#: ../../library/asyncio-task.rst:618
msgid ""
"This function is meant to be called from a different OS thread than the one "
"where the event loop is running.  Example::"
msgstr ""
"この関数は、イベントループが動作しているスレッドとは異なる OS スレッドから呼"
"び出すためのものです。\n"
"例えば次のように使います::"

#: ../../library/asyncio-task.rst:630
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 ""
"コルーチンから例外が送出された場合、返された Future に通知されます。\n"
"これはイベントループの Task をキャンセルするのにも使えます::"

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

#: ../../library/asyncio-task.rst:647
msgid ""
"Unlike other asyncio functions this function requires the *loop* argument to "
"be passed explicitly."
msgstr ""
"他の asyncio 関数とは異なり、この関数は明示的に渡される *loop* 引数を必要とし"
"ます。"

#: ../../library/asyncio-task.rst:654
msgid "Introspection"
msgstr "イントロスペクション"

#: ../../library/asyncio-task.rst:659
msgid ""
"Return the currently running :class:`Task` instance, or ``None`` if no task "
"is running."
msgstr ""
"現在実行中の :class:`Task` インスタンスを返します。実行中の Task が無い場合"
"は ``None`` を返します。"

#: ../../library/asyncio-task.rst:662
msgid ""
"If *loop* is ``None`` :func:`get_running_loop` is used to get the current "
"loop."
msgstr ""
"*loop* が ``None`` の場合、 :func:`get_running_loop` が現在のループを取得する"
"のに使われます。"

#: ../../library/asyncio-task.rst:670
msgid "Return a set of not yet finished :class:`Task` objects run by the loop."
msgstr ""
"ループで実行された :class:`Task` オブジェクトでまだ完了していないものの集合を"
"返します。"

#: ../../library/asyncio-task.rst:673
msgid ""
"If *loop* is ``None``, :func:`get_running_loop` is used for getting current "
"loop."
msgstr ""
"*loop* が ``None`` の場合、 :func:`get_running_loop` は現在のループを取得する"
"のに使われます。"

#: ../../library/asyncio-task.rst:680
msgid "Task Object"
msgstr "Task オブジェクト"

#: ../../library/asyncio-task.rst:684
msgid ""
"A :class:`Future-like <Future>` object that runs a Python :ref:`coroutine "
"<coroutine>`.  Not thread-safe."
msgstr ""
"Python :ref:`コルーチン <coroutine>` を実行する :class:`Future 類 <Future>` "
"オブジェクトです。\n"
"スレッドセーフではありません。"

#: ../../library/asyncio-task.rst:687
msgid ""
"Tasks are used to run coroutines in event loops. If a coroutine awaits on a "
"Future, the Task suspends the execution of the coroutine and waits for the "
"completion of the Future.  When the Future is *done*, the execution of the "
"wrapped coroutine resumes."
msgstr ""
"Task はイベントループのコルーチンを実行するのに使われます。\n"
"Future でコルーチンが待機している場合、 Task は自身のコルーチンの実行を一時停"
"止させ、 Future の完了を待ちます。\n"
"Future が *完了* したら、 Task が内包しているコルーチンの実行を再開します。"

#: ../../library/asyncio-task.rst:693
msgid ""
"Event loops use cooperative scheduling: an event loop runs one Task at a "
"time.  While a Task awaits for the completion of a Future, the event loop "
"runs other Tasks, callbacks, or performs IO operations."
msgstr ""
"イベントループは協調スケジューリングを使用します。つまり、イベントループは同"
"時に 1 つの Task のみ実行します。\n"
"Task が Future の完了を待っているときは、イベントループは他の Task やコール"
"バックを動作させるか、 IO 処理を実行します。"

#: ../../library/asyncio-task.rst:698
msgid ""
"Use the high-level :func:`asyncio.create_task` function to create Tasks, or "
"the low-level :meth:`loop.create_task` or :func:`ensure_future` functions.  "
"Manual instantiation of Tasks is discouraged."
msgstr ""
"Task を作成するには高レベルの :func:`asyncio.create_task` 関数、あるいは低レ"
"ベルの :meth:`loop.create_task` 関数や :func:`ensure_future` 関数を使用してく"
"ださい。\n"
"手作業での Task の実装は推奨されません。"

#: ../../library/asyncio-task.rst:703
msgid ""
"To cancel a running Task use the :meth:`cancel` method.  Calling it will "
"cause the Task to throw a :exc:`CancelledError` exception into the wrapped "
"coroutine.  If a coroutine is awaiting on a Future object during "
"cancellation, the Future object will be cancelled."
msgstr ""
"実行中のタスクをキャンセルするためには、:meth:`cancel` メソッドを使用します。"
"このメソッドを呼ぶと、タスクはそれを内包するコルーチンに対して :exc:"
"`CancelledError` 例外を送出します。キャンセルの際にコルーチンが Future オブ"
"ジェクトを待っていた場合、その Future オブジェクトはキャンセルされます。"

#: ../../library/asyncio-task.rst:708
msgid ""
":meth:`cancelled` can be used to check if the Task was cancelled. The method "
"returns ``True`` if the wrapped coroutine did not suppress the :exc:"
"`CancelledError` exception and was actually cancelled."
msgstr ""
":meth:`cancelled` は、タスクがキャンセルされたかを調べるのに使用できます。タ"
"スクを内包するコルーチンで :exc:`CancelledError` 例外が抑制されておらず、かつ"
"タスクが実際にキャンセルされている場合に、このメソッドは ``True`` を変えま"
"す。"

#: ../../library/asyncio-task.rst:713
msgid ""
":class:`asyncio.Task` inherits from :class:`Future` all of its APIs except :"
"meth:`Future.set_result` and :meth:`Future.set_exception`."
msgstr ""
":class:`asyncio.Task` は、:meth:`Future.set_result` と :meth:`Future."
"set_exception` を除いて、:class:`Future` の API をすべて継承しています。"

#: ../../library/asyncio-task.rst:717
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."
msgstr ""
"Task は :mod:`contextvars` モジュールをサポートします。Task が作られたときに"
"現在のコンテキストがコピーされ、のちに Task のコルーチンを実行する際に、コ"
"ピーされたコンテキストが使用されます。"

#: ../../library/asyncio-task.rst:721
msgid "Added support for the :mod:`contextvars` module."
msgstr ":mod:`contextvars` モジュールのサポートを追加。"

#: ../../library/asyncio-task.rst:732
msgid "Request the Task to be cancelled."
msgstr "このタスクに、自身のキャンセルを要求します。"

#: ../../library/asyncio-task.rst:734
msgid ""
"This arranges for a :exc:`CancelledError` exception to be thrown into the "
"wrapped coroutine on the next cycle of the event loop."
msgstr ""
"このメソッドは、イベントループの次のステップにおいて、タスクがラップしている"
"コルーチン内で :exc:`CancelledError` 例外が送出されるように準備します。"

#: ../../library/asyncio-task.rst:737
msgid ""
"The coroutine then has a chance to clean up or even deny the request by "
"suppressing the exception with a :keyword:`try` ... ... ``except "
"CancelledError`` ... :keyword:`finally` block. Therefore, unlike :meth:"
"`Future.cancel`, :meth:`Task.cancel` does not guarantee that the Task will "
"be cancelled, although suppressing cancellation completely is not common and "
"is actively discouraged."
msgstr ""
"コルーチン側では :keyword:`try` ... ... ``except CancelledError`` ... :"
"keyword:`finally` ブロックで例外を処理することにより、クリーンアップ処理を行"
"なったり、リクエストを拒否したりする機会が与えられます。この特性を使ってキャ"
"ンセル処理を完全に抑え込むことも可能であることから、 :meth:`Future.cancel` と"
"異なり、 :meth:`Task.cancel` は Task が実際にキャンセルされることを保証しませ"
"ん。ただしそのような処理は一般的ではありませんし、そのような処理をしないこと"
"が望ましいです。"

#: ../../library/asyncio-task.rst:747
msgid ""
"The following example illustrates how coroutines can intercept the "
"cancellation request::"
msgstr ""
"以下の例は、コルーチンがどのようにしてキャンセルのリクエストを阻止するかを示"
"しています::"

#: ../../library/asyncio-task.rst:786
msgid "Return ``True`` if the Task is *cancelled*."
msgstr "Task が *キャンセルされた* 場合に ``True`` を返します。"

#: ../../library/asyncio-task.rst:788
msgid ""
"The Task is *cancelled* when the cancellation was requested with :meth:"
"`cancel` and the wrapped coroutine propagated the :exc:`CancelledError` "
"exception thrown into it."
msgstr ""
":meth:`cancel` メソッドによりキャンセルがリクエストされ、かつ Task がラップし"
"ているコルーチンが内部で送出された :exc:`CancelledError` 例外を伝達したと"
"き、 Task は実際に *キャンセル* されます。"

#: ../../library/asyncio-task.rst:794
msgid "Return ``True`` if the Task is *done*."
msgstr "Task が *完了* しているなら ``True`` を返します。"

#: ../../library/asyncio-task.rst:796
msgid ""
"A Task is *done* when the wrapped coroutine either returned a value, raised "
"an exception, or the Task was cancelled."
msgstr ""
"Task がラップしているコルーチンが値を返すか、例外を送出するか、または Task が"
"キャンセルされたとき、 Task は *完了* します。"

#: ../../library/asyncio-task.rst:801
msgid "Return the result of the Task."
msgstr "Task の結果を返します。"

#: ../../library/asyncio-task.rst:803
msgid ""
"If the Task is *done*, the result of the wrapped coroutine is returned (or "
"if the coroutine raised an exception, that exception is re-raised.)"
msgstr ""
"Task が *完了* している場合、ラップしているコルーチンの結果が返されます (コ"
"ルーチンが例外を送出された場合、その例外が例外が再送出されます)"

#: ../../library/asyncio-task.rst:807 ../../library/asyncio-task.rst:821
msgid ""
"If the Task has been *cancelled*, this method raises a :exc:`CancelledError` "
"exception."
msgstr ""
"Task が *キャンセル* されている場合、このメソッドは :exc:`CancelledError` 例"
"外を送出します。"

#: ../../library/asyncio-task.rst:810
msgid ""
"If the Task's result isn't yet available, this method raises a :exc:"
"`InvalidStateError` exception."
msgstr ""
"Task の結果がまだ未設定の場合、このメソッドは :exc:`InvalidStateError` 例外を"
"送出します。"

#: ../../library/asyncio-task.rst:815
msgid "Return the exception of the Task."
msgstr "Task の例外を返します。"

#: ../../library/asyncio-task.rst:817
msgid ""
"If the wrapped coroutine raised an exception that exception is returned.  If "
"the wrapped coroutine returned normally this method returns ``None``."
msgstr ""
"ラップされたコルーチンが例外を送出した場合、その例外が返されます。ラップされ"
"たコルーチンが正常終了した場合、このメソッドは ``None`` を返します。"

#: ../../library/asyncio-task.rst:824
msgid ""
"If the Task isn't *done* yet, this method raises an :exc:`InvalidStateError` "
"exception."
msgstr ""
"Task がまだ *完了* していない場合、このメソッドは :exc:`InvalidStateError` 例"
"外を送出します。"

#: ../../library/asyncio-task.rst:829
msgid "Add a callback to be run when the Task is *done*."
msgstr "Task が *完了* したときに実行されるコールバックを追加します。"

#: ../../library/asyncio-task.rst:831 ../../library/asyncio-task.rst:840
msgid "This method should only be used in low-level callback-based code."
msgstr "このメソッドは低水準のコールバックベースのコードでのみ使うべきです。"

#: ../../library/asyncio-task.rst:833
msgid ""
"See the documentation of :meth:`Future.add_done_callback` for more details."
msgstr ""
"詳細については :meth:`Future.add_done_callback` のドキュメントを参照してくだ"
"さい。"

#: ../../library/asyncio-task.rst:838
msgid "Remove *callback* from the callbacks list."
msgstr "コールバックリストから *callback* を削除します。"

#: ../../library/asyncio-task.rst:842
msgid ""
"See the documentation of :meth:`Future.remove_done_callback` for more "
"details."
msgstr ""
"詳細については :meth:`Future.remove_done_callback` のドキュメントを参照してく"
"ださい。"

#: ../../library/asyncio-task.rst:847
msgid "Return the list of stack frames for this Task."
msgstr "このタスクのスタックフレームのリストを返します。"

#: ../../library/asyncio-task.rst:849
msgid ""
"If the wrapped 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:855
msgid "The frames are always ordered from oldest to newest."
msgstr "フレームは常に古いものから新しい物へ並んでいます。"

#: ../../library/asyncio-task.rst:857
msgid "Only one stack frame is returned for a suspended coroutine."
msgstr ""
"サスペンドされているコルーチンの場合スタックフレームが 1 個だけ返されます。"

#: ../../library/asyncio-task.rst:859
msgid ""
"The optional *limit* argument sets the maximum number of frames to return; "
"by default all available frames are returned. The ordering of the returned "
"list 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:868
msgid "Print the stack or traceback for this Task."
msgstr "このタスクのスタックまたはトレースバックを出力します。"

#: ../../library/asyncio-task.rst:870
msgid ""
"This produces output similar to that of the traceback module for the frames "
"retrieved by :meth:`get_stack`."
msgstr ""
"このメソッドは :meth:`get_stack` によって取得されるフレームに対し、 "
"traceback モジュールと同じような出力を生成します。"

#: ../../library/asyncio-task.rst:873
msgid "The *limit* argument is passed to :meth:`get_stack` directly."
msgstr "引数 *limit* は :meth:`get_stack` にそのまま渡されます。"

#: ../../library/asyncio-task.rst:875
msgid ""
"The *file* argument is an I/O stream to which the output is written; by "
"default output is written to :data:`sys.stderr`."
msgstr ""
"引数 *file* は出力を書き込む I/O ストリームを指定します; デフォルトでは出力は"
"標準エラー出力 :data:`sys.stderr` に書き込まれます。"

#: ../../library/asyncio-task.rst:880
msgid "Return the coroutine object wrapped by the :class:`Task`."
msgstr ":class:`Task` がラップしているコルーチンオブジェクトを返します。"

#: ../../library/asyncio-task.rst:886
msgid "Return the name of the Task."
msgstr "Task の名前を返します。"

#: ../../library/asyncio-task.rst:888
msgid ""
"If no name has been explicitly assigned to the Task, the default asyncio "
"Task implementation generates a default name during instantiation."
msgstr ""
"Task に対して明示的に名前が設定されていない場合, デフォルトの asyncio Task 実"
"装はタスクをインスタンス化する際にデフォルトの名前を生成します。"

#: ../../library/asyncio-task.rst:896
msgid "Set the name of the Task."
msgstr "Task に名前を設定します。"

#: ../../library/asyncio-task.rst:898
msgid ""
"The *value* argument can be any object, which is then converted to a string."
msgstr ""
"引数 *value* は文字列に変換可能なオブジェクトであれば何でもかまいません。"

#: ../../library/asyncio-task.rst:901
msgid ""
"In the default Task implementation, the name will be visible in the :func:"
"`repr` output of a task object."
msgstr ""
"Task のデフォルト実装では、名前はオブジェクトの :func:`repr` メソッドの出力で"
"確認できます。"

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

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

#: ../../library/asyncio-task.rst:916
msgid ""
"Do not call this as a task method. Use the :func:`asyncio.all_tasks` "
"function instead."
msgstr ""

#: ../../library/asyncio-task.rst:921
msgid "Return the currently running task or ``None``."
msgstr ""

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

#: ../../library/asyncio-task.rst:928
msgid ""
"Do not call this as a task method.  Use the :func:`asyncio.current_task` "
"function instead."
msgstr ""

#: ../../library/asyncio-task.rst:935
msgid "Generator-based Coroutines"
msgstr ""

#: ../../library/asyncio-task.rst:939
msgid ""
"Support for generator-based coroutines is **deprecated** and is scheduled "
"for removal in Python 3.10."
msgstr ""

#: ../../library/asyncio-task.rst:942
msgid ""
"Generator-based coroutines predate async/await syntax.  They are Python "
"generators that use ``yield from`` expressions to await on Futures and other "
"coroutines."
msgstr ""

#: ../../library/asyncio-task.rst:946
msgid ""
"Generator-based coroutines should be decorated with :func:`@asyncio."
"coroutine <asyncio.coroutine>`, although this is not enforced."
msgstr ""

#: ../../library/asyncio-task.rst:953
msgid "Decorator to mark generator-based coroutines."
msgstr ""

#: ../../library/asyncio-task.rst:955
msgid ""
"This decorator enables legacy generator-based coroutines to be compatible "
"with async/await code::"
msgstr ""

#: ../../library/asyncio-task.rst:965
msgid "This decorator should not be used for :keyword:`async def` coroutines."
msgstr ""

#: ../../library/asyncio-task.rst:970
msgid "Use :keyword:`async def` instead."
msgstr ""

#: ../../library/asyncio-task.rst:974
msgid "Return ``True`` if *obj* is a :ref:`coroutine object <coroutine>`."
msgstr ""
"*obj* が :ref:`コルーチンオブジェクト <coroutine>` であれば ``True`` を返しま"
"す。"

#: ../../library/asyncio-task.rst:976
msgid ""
"This method is different from :func:`inspect.iscoroutine` because it returns "
"``True`` for generator-based coroutines."
msgstr ""

#: ../../library/asyncio-task.rst:981
msgid "Return ``True`` if *func* is a :ref:`coroutine function <coroutine>`."
msgstr ""

#: ../../library/asyncio-task.rst:984
msgid ""
"This method is different from :func:`inspect.iscoroutinefunction` because it "
"returns ``True`` for generator-based coroutine functions decorated with :"
"func:`@coroutine <coroutine>`."
msgstr ""