# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001 Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# python-doc bot, 2026

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.14\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2026-04-09 15:16+0000\n"

"PO-Revision-Date: 2025-09-16 00:00+0000\n"

"Last-Translator: python-doc bot, 2026\n"

"Language-Team: Japanese (https://app.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-dev.rst:7

msgid "Developing with asyncio"

msgstr "asyncio での開発"

#: ../../library/asyncio-dev.rst:9

msgid ""

"Asynchronous programming is different from classic \"sequential\" "

"programming."

msgstr ""

"非同期プログラミングは伝統的な \"同期的\" プログラミングとは異なります。"

#: ../../library/asyncio-dev.rst:12

msgid ""

"This page lists common mistakes and traps and explains how to avoid them."

msgstr ""

"このページはよくある間違いや落とし穴を列挙し、それらを回避する方法を説明しま"

"す。"

#: ../../library/asyncio-dev.rst:19

msgid "Debug Mode"

msgstr "デバッグモード"

#: ../../library/asyncio-dev.rst:21

msgid ""

"By default asyncio runs in production mode. In order to ease the "

"development asyncio has a *debug mode*."

msgstr ""

"asyncio はデフォルトで本運用モードで実行されます。いっぽう、開発を容易にする"

"ために asyncio は \"デバッグモード\" を持っています。"

#: ../../library/asyncio-dev.rst:24

msgid "There are several ways to enable asyncio debug mode:"

msgstr "asyncio のデバッグモードを有効化する方法はいくつかあります:"

#: ../../library/asyncio-dev.rst:26

msgid "Setting the :envvar:`PYTHONASYNCIODEBUG` environment variable to ``1``."

msgstr ":envvar:`PYTHONASYNCIODEBUG` 環境変数の値を ``1`` に設定する。"

#: ../../library/asyncio-dev.rst:28

msgid "Using the :ref:`Python Development Mode <devmode>`."

msgstr ":ref:`Python 開発モード <devmode>` を使う。"

#: ../../library/asyncio-dev.rst:30

msgid "Passing ``debug=True`` to :func:`asyncio.run`."

msgstr ":func:`asyncio.run` 実行時に ``debug=True`` を設定する。"

#: ../../library/asyncio-dev.rst:32

msgid "Calling :meth:`loop.set_debug`."

msgstr ":meth:`loop.set_debug` を呼び出す。"

#: ../../library/asyncio-dev.rst:34

msgid "In addition to enabling the debug mode, consider also:"

msgstr "デバッグモードを有効化することに加え、以下も検討してください:"

#: ../../library/asyncio-dev.rst:36

msgid ""

"setting the log level of the :ref:`asyncio logger <asyncio-logger>` to :py:"

"const:`logging.DEBUG`, for example the following snippet of code can be run "

"at startup of the application::"

msgstr ""

":ref:`asyncio ロガー <asyncio-logger>` のログレベルを :py:const:`logging."

"DEBUG` に設定します。例えばアプリケーションの起動時に以下を実行します::"

#: ../../library/asyncio-dev.rst:40

msgid "logging.basicConfig(level=logging.DEBUG)"

msgstr ""

#: ../../library/asyncio-dev.rst:42

msgid ""

"configuring the :mod:`warnings` module to display :exc:`ResourceWarning` "

"warnings. One way of doing that is by using the :option:`-W` ``default`` "

"command line option."

msgstr ""

":mod:`warnings` モジュールが :exc:`ResourceWarning` 警告を表示するように設定"

"します。やり方のひとつは :option:`-W` ``default`` コマンドラインオプションを"

"使うことです。"

#: ../../library/asyncio-dev.rst:47

msgid "When the debug mode is enabled:"

msgstr "デバッグモードが有効化されたときの動作:"

#: ../../library/asyncio-dev.rst:49

msgid ""

"Many non-threadsafe asyncio APIs (such as :meth:`loop.call_soon` and :meth:"

"`loop.call_at` methods) raise an exception if they are called from a wrong "

"thread."

msgstr ""

"スレッドセーフでない asyncio APIs の多く (:meth:`loop.call_soon` や :meth:"

"`loop.call_at` など) は、誤ったスレッドから呼び出されたときに例外を送出しま"

"す。"

#: ../../library/asyncio-dev.rst:53

msgid ""

"The execution time of the I/O selector is logged if it takes too long to "

"perform an I/O operation."

msgstr ""

"I/O セレクタが I/O 処理を実行する時間が長すぎる場合、その実行時間が記録されま"

"す。"

#: ../../library/asyncio-dev.rst:56

msgid ""

"Callbacks taking longer than 100 milliseconds are logged. The :attr:`loop."

"slow_callback_duration` attribute can be used to set the minimum execution "

"duration in seconds that is considered \"slow\"."

msgstr ""

"実行時間が100ミリ秒を超えるコールバックは記録されます。 \"遅い\" の判断基準と"

"なる実行時間の最小値は :attr:`loop.slow_callback_duration` 属性で設定できま"

"す。"

#: ../../library/asyncio-dev.rst:64

msgid "Concurrency and Multithreading"

msgstr "並行処理とマルチスレッド処理"

#: ../../library/asyncio-dev.rst:66

msgid ""

"An event loop runs in a thread (typically the main thread) and executes all "

"callbacks and Tasks in its thread. While a Task is running in the event "

"loop, no other Tasks can run in the same thread. When a Task executes an "

"``await`` expression, the running Task gets suspended, and the event loop "

"executes the next Task."

msgstr ""

"イベントループはスレッド（典型的にはメインスレッド）内で動作し、すべてのコー"

"ルバックとタスクをそのスレッド内で実行します。ひとつのタスクがイベントループ"

"内で実行される間、他のタスクを同じスレッド内で実行することはできません。タス"

"クが ``await`` 式を実行すると、実行中のタスクはサスペンドされ、イベントループ"

"は次のタスクを実行します。"

#: ../../library/asyncio-dev.rst:72

msgid ""

"To schedule a :term:`callback` from another OS thread, the :meth:`loop."

"call_soon_threadsafe` method should be used. Example::"

msgstr ""

"別の OS スレッドからのコールバック (:term:`callback`) をスケジュールする場"

"合、 :meth:`loop.call_soon_threadsafe` メソッドを使ってください。例:"

#: ../../library/asyncio-dev.rst:75

msgid "loop.call_soon_threadsafe(callback, *args)"

msgstr ""

#: ../../library/asyncio-dev.rst:77

msgid ""

"Almost all asyncio objects are not thread safe, which is typically not a "

"problem unless there is code that works with them from outside of a Task or "

"a callback. If there's a need for such code to call a low-level asyncio "

"API, the :meth:`loop.call_soon_threadsafe` method should be used, e.g.::"

msgstr ""

"ほぼ全ての非同期オブジェクトはスレッドセーフではありませんが、タスクやコール"

"バックの外側で非同期オブジェクトを使うコードが存在しない限り、それが問題には"

"なることはほとんどありません。もしそのような目的で低レベルの asyncio API を呼"

"び出すようなコードを書く必要がある場合、 :meth:`loop.call_soon_threadsafe` メ"

"ソッドを使ってください。例: "

#: ../../library/asyncio-dev.rst:83

msgid "loop.call_soon_threadsafe(fut.cancel)"

msgstr ""

#: ../../library/asyncio-dev.rst:85

msgid ""

"To schedule a coroutine object from a different OS thread, the :func:"

"`run_coroutine_threadsafe` function should be used. It returns a :class:"

"`concurrent.futures.Future` to access the result::"

msgstr ""

"別の OS スレッドからコルーチンオブジェクトをスケジュールする場合は、 :func:"

"`run_coroutine_threadsafe` メソッドを使ってください。 :func:"

"`run_coroutine_threadsafe` は結果にアクセスするための :class:`concurrent."

"futures.Future` オブジェクトを返します:"

#: ../../library/asyncio-dev.rst:89

msgid ""

"async def coro_func():\n"

" return await asyncio.sleep(1, 42)\n"

"\n"

"# Later in another OS thread:\n"

"\n"

"future = asyncio.run_coroutine_threadsafe(coro_func(), loop)\n"

"# Wait for the result:\n"

"result = future.result()"

msgstr ""

#: ../../library/asyncio-dev.rst:98

msgid "To handle signals the event loop must be run in the main thread."

msgstr ""

"シグナルの処理を行うには、イベントループはメインスレッド内で実行しなければな"

"りません。"

#: ../../library/asyncio-dev.rst:101

msgid ""

"The :meth:`loop.run_in_executor` method can be used with a :class:"

"`concurrent.futures.ThreadPoolExecutor` or :class:`~concurrent.futures."

"InterpreterPoolExecutor` to execute blocking code in a different OS thread "

"without blocking the OS thread that the event loop runs in."

msgstr ""

#: ../../library/asyncio-dev.rst:107

msgid ""

"There is currently no way to schedule coroutines or callbacks directly from "

"a different process (such as one started with :mod:`multiprocessing`). The :"

"ref:`asyncio-event-loop-methods` section lists APIs that can read from pipes "

"and watch file descriptors without blocking the event loop. In addition, "

"asyncio's :ref:`Subprocess <asyncio-subprocess>` APIs provide a way to start "

"a process and communicate with it from the event loop. Lastly, the "

"aforementioned :meth:`loop.run_in_executor` method can also be used with a :"

"class:`concurrent.futures.ProcessPoolExecutor` to execute code in a "

"different process."

msgstr ""

"現在のところ、 (たとえば :mod:`multiprocessing` で開始したような) 別のプロセ"

"スからコルーチンやコールバックを直接スケジュールすることはできません。 :ref:"

"`asyncio-event-loop-methods` 節では、イベントループをブロックすることなくパイ"

"プからの読み込みやファイルデスクリプタの監視ができる API のリストを掲載してい"

"ます。さらに、 asyncio の :ref:`サブプロセス <asyncio-subprocess>` API はイベ"

"ントループからプロセスを開始したりプロセスと通信したりする方法を提供します。 "

"最後に、前述の :meth:`loop.run_in_executor` メソッドは :class:`concurrent."

"futures.ProcessPoolExecutor` とともに使用することで、別のプロセス内でコードを"

"実行することもできます。"

#: ../../library/asyncio-dev.rst:121

msgid "Running Blocking Code"

msgstr "ブロッキングコードの実行"

#: ../../library/asyncio-dev.rst:123

msgid ""

"Blocking (CPU-bound) code should not be called directly. For example, if a "

"function performs a CPU-intensive calculation for 1 second, all concurrent "

"asyncio Tasks and IO operations would be delayed by 1 second."

msgstr ""

"ブロッキングコード (CPU バウンドなコード) を直接呼び出すべきではありません。"

"たとえば、 CPU 負荷の高い関数を1秒実行したとすると、並行に処理されている全て"

"の非同期タスクと I/O 処理は1秒遅れる可能性があります。 "

#: ../../library/asyncio-dev.rst:128

msgid ""

"An executor can be used to run a task in a different thread, including in a "

"different interpreter, or even in a different process to avoid blocking the "

"OS thread with the event loop. See the :meth:`loop.run_in_executor` method "

"for more details."

msgstr ""

#: ../../library/asyncio-dev.rst:138

msgid "Logging"

msgstr "ログ記録"

#: ../../library/asyncio-dev.rst:140

msgid ""

"asyncio uses the :mod:`logging` module and all logging is performed via the "

"``\"asyncio\"`` logger."

msgstr ""

"asyncio は :mod:`logging` モジュールを利用し、 全てのログ記録は "

"``\"asyncio\"`` ロガーを通じて行われます。"

#: ../../library/asyncio-dev.rst:143

msgid ""

"The default log level is :py:const:`logging.INFO`, which can be easily "

"adjusted::"

msgstr ""

"デフォルトのログレベルは :py:const:`logging.INFO` ですが、これは簡単に調節で"

"きます:"

#: ../../library/asyncio-dev.rst:146

msgid "logging.getLogger(\"asyncio\").setLevel(logging.WARNING)"

msgstr ""

#: ../../library/asyncio-dev.rst:149

msgid ""

"Network logging can block the event loop. It is recommended to use a "

"separate thread for handling logs or use non-blocking IO. For example, see :"

"ref:`blocking-handlers`."

msgstr ""

"ネットワークログ記録は、イベントループをブロックし得ます。ログ処理のスレッド"

"を分離するか、ノンブロッキング IO を使用することを推奨します。例えば、 :ref:"

"`blocking-handlers` を見てください。"

#: ../../library/asyncio-dev.rst:157

msgid "Detect never-awaited coroutines"

msgstr "待ち受け処理を伴わないコルーチンの検出"

#: ../../library/asyncio-dev.rst:159

msgid ""

"When a coroutine function is called, but not awaited (e.g. ``coro()`` "

"instead of ``await coro()``) or the coroutine is not scheduled with :meth:"

"`asyncio.create_task`, asyncio will emit a :exc:`RuntimeWarning`::"

msgstr ""

"コルーチンが呼び出されただけで、待ち受け処理がない場合 (たとえば ``await "

"coro()`` のかわりに ``coro()`` と書いてしまった場合) 、またはコルーチンが :"

"meth:`asyncio.create_task` を使わずにスケジュールされた場合、 asyncio は :"

"exc:`RuntimeWarning` 警告を送出します:"

#: ../../library/asyncio-dev.rst:164

msgid ""

"import asyncio\n"

"\n"

"async def test():\n"

" print(\"never scheduled\")\n"

"\n"

"async def main():\n"

" test()\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: ../../library/asyncio-dev.rst:174 ../../library/asyncio-dev.rst:219

#: ../../library/asyncio-dev.rst:393 ../../library/asyncio-dev.rst:450

msgid "Output::"

msgstr "出力::"

#: ../../library/asyncio-dev.rst:176

msgid ""

"test.py:7: RuntimeWarning: coroutine 'test' was never awaited\n"

" test()"

msgstr ""

#: ../../library/asyncio-dev.rst:179 ../../library/asyncio-dev.rst:235

msgid "Output in debug mode::"

msgstr "デバッグモードの出力::"

#: ../../library/asyncio-dev.rst:181

msgid ""

"test.py:7: RuntimeWarning: coroutine 'test' was never awaited\n"

"Coroutine created at (most recent call last)\n"

" File \"../t.py\", line 9, in <module>\n"

" asyncio.run(main(), debug=True)\n"

"\n"

" < .. >\n"

"\n"

" File \"../t.py\", line 7, in main\n"

" test()\n"

" test()"

msgstr ""

#: ../../library/asyncio-dev.rst:192

msgid ""

"The usual fix is to either await the coroutine or call the :meth:`asyncio."

"create_task` function::"

msgstr ""

"通常の修正方法はコルーチンを待ち受ける (await) か、 :meth:`asyncio."

"create_task` 関数を呼び出すことです:"

#: ../../library/asyncio-dev.rst:195

msgid ""

"async def main():\n"

" await test()"

msgstr ""

#: ../../library/asyncio-dev.rst:200

msgid "Detect never-retrieved exceptions"

msgstr "回収されない例外の検出"

#: ../../library/asyncio-dev.rst:202

msgid ""

"If a :meth:`Future.set_exception` is called but the Future object is never "

"awaited on, the exception would never be propagated to the user code. In "

"this case, asyncio would emit a log message when the Future object is "

"garbage collected."

msgstr ""

"もし :meth:`Future.set_exception` メソッドが呼び出されても、その Future オブ"

"ジェクトを待ち受けていなければ、例外は決してユーザーコードまで伝播しません。"

"この場合 asyncio は、 Future オブジェクトがガベージコレクションの対象となった"

"ときにログメッセージを送出することがあります。"

#: ../../library/asyncio-dev.rst:207

msgid "Example of an unhandled exception::"

msgstr "処理されない例外の例:"

#: ../../library/asyncio-dev.rst:209

msgid ""

"import asyncio\n"

"\n"

"async def bug():\n"

" raise Exception(\"not consumed\")\n"

"\n"

"async def main():\n"

" asyncio.create_task(bug())\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: ../../library/asyncio-dev.rst:221

msgid ""

"Task exception was never retrieved\n"

"future: <Task finished coro=<bug() done, defined at test.py:3>\n"

" exception=Exception('not consumed')>\n"

"\n"

"Traceback (most recent call last):\n"

" File \"test.py\", line 4, in bug\n"

" raise Exception(\"not consumed\")\n"

"Exception: not consumed"

msgstr ""

#: ../../library/asyncio-dev.rst:230

msgid ""

":ref:`Enable the debug mode <asyncio-debug-mode>` to get the traceback where "

"the task was created::"

msgstr ""

"タスクが生成された箇所を特定するには、 :ref:`デバッグモードを有効化して "

"<asyncio-debug-mode>` トレースバックを取得してください:"

#: ../../library/asyncio-dev.rst:233

msgid "asyncio.run(main(), debug=True)"

msgstr ""

#: ../../library/asyncio-dev.rst:237

msgid ""

"Task exception was never retrieved\n"

"future: <Task finished coro=<bug() done, defined at test.py:3>\n"

" exception=Exception('not consumed') created at asyncio/tasks.py:321>\n"

"\n"

"source_traceback: Object created at (most recent call last):\n"

" File \"../t.py\", line 9, in <module>\n"

" asyncio.run(main(), debug=True)\n"

"\n"

"< .. >\n"

"\n"

"Traceback (most recent call last):\n"

" File \"../t.py\", line 4, in bug\n"

" raise Exception(\"not consumed\")\n"

"Exception: not consumed"

msgstr ""

#: ../../library/asyncio-dev.rst:254

msgid "Asynchronous generators best practices"

msgstr ""

#: ../../library/asyncio-dev.rst:256

msgid ""

"Writing correct and efficient asyncio code requires awareness of certain "

"pitfalls. This section outlines essential best practices that can save you "

"hours of debugging."

msgstr ""

#: ../../library/asyncio-dev.rst:261

msgid "Close asynchronous generators explicitly"

msgstr ""

#: ../../library/asyncio-dev.rst:263

msgid ""

"It is recommended to manually close the :term:`asynchronous generator "

"<asynchronous generator iterator>`. If a generator exits early - for "

"example, due to an exception raised in the body of an ``async for`` loop - "

"its asynchronous cleanup code may run in an unexpected context. This can "

"occur after the tasks it depends on have completed, or during the event loop "

"shutdown when the async-generator's garbage collection hook is called."

msgstr ""

#: ../../library/asyncio-dev.rst:271

msgid ""

"To avoid this, explicitly close the generator by calling its :meth:`~agen."

"aclose` method, or use the :func:`contextlib.aclosing` context manager::"

msgstr ""

#: ../../library/asyncio-dev.rst:275

msgid ""

"import asyncio\n"

"import contextlib\n"

"\n"

"async def gen():\n"

" yield 1\n"

" yield 2\n"

"\n"

"async def func():\n"

" async with contextlib.aclosing(gen()) as g:\n"

" async for x in g:\n"

" break # Don't iterate until the end\n"

"\n"

"asyncio.run(func())"

msgstr ""

#: ../../library/asyncio-dev.rst:289

msgid ""

"As noted above, the cleanup code for these asynchronous generators is "

"deferred. The following example demonstrates that the finalization of an "

"asynchronous generator can occur in an unexpected order::"

msgstr ""

#: ../../library/asyncio-dev.rst:293

msgid ""

"import asyncio\n"

"work_done = False\n"

"\n"

"async def cursor():\n"

" try:\n"

" yield 1\n"

" finally:\n"

" assert work_done\n"

"\n"

"async def rows():\n"

" global work_done\n"

" try:\n"

" yield 2\n"

" finally:\n"

" await asyncio.sleep(0.1) # immitate some async work\n"

" work_done = True\n"

"\n"

"\n"

"async def main():\n"

" async for c in cursor():\n"

" async for r in rows():\n"

" break\n"

" break\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: ../../library/asyncio-dev.rst:319

msgid "For this example, we get the following output::"

msgstr ""

#: ../../library/asyncio-dev.rst:321

msgid ""

"unhandled exception during asyncio.run() shutdown\n"

"task: <Task finished name='Task-3' coro=<<async_generator_athrow without "

"__name__>()> exception=AssertionError()>\n"

"Traceback (most recent call last):\n"

" File \"example.py\", line 6, in cursor\n"

" yield 1\n"

"asyncio.exceptions.CancelledError\n"

"\n"

"During handling of the above exception, another exception occurred:\n"

"\n"

"Traceback (most recent call last):\n"

" File \"example.py\", line 8, in cursor\n"

" assert work_done\n"

" ^^^^^^^^^\n"

"AssertionError"

msgstr ""

#: ../../library/asyncio-dev.rst:336

msgid ""

"The ``cursor()`` asynchronous generator was finalized before the ``rows`` "

"generator - an unexpected behavior."

msgstr ""

#: ../../library/asyncio-dev.rst:339

msgid ""

"The example can be fixed by explicitly closing the ``cursor`` and ``rows`` "

"async-generators::"

msgstr ""

#: ../../library/asyncio-dev.rst:342

msgid ""

"async def main():\n"

" async with contextlib.aclosing(cursor()) as cursor_gen:\n"

" async for c in cursor_gen:\n"

" async with contextlib.aclosing(rows()) as rows_gen:\n"

" async for r in rows_gen:\n"

" break\n"

" break"

msgstr ""

#: ../../library/asyncio-dev.rst:352

msgid "Create asynchronous generators only when the event loop is running"

msgstr ""

#: ../../library/asyncio-dev.rst:354

msgid ""

"It is recommended to create :term:`asynchronous generators <asynchronous "

"generator iterator>` only after the event loop has been created."

msgstr ""

#: ../../library/asyncio-dev.rst:358

msgid ""

"To ensure that asynchronous generators close reliably, the event loop uses "

"the :func:`sys.set_asyncgen_hooks` function to register callback functions. "

"These callbacks update the list of running asynchronous generators to keep "

"it in a consistent state."

msgstr ""

#: ../../library/asyncio-dev.rst:363

msgid ""

"When the :meth:`loop.shutdown_asyncgens() <asyncio.loop.shutdown_asyncgens>` "

"function is called, the running generators are stopped gracefully and the "

"list is cleared."

msgstr ""

#: ../../library/asyncio-dev.rst:367

msgid ""

"The asynchronous generator invokes the corresponding system hook during its "

"first iteration. At the same time, the generator records that the hook has "

"been called and does not call it again."

msgstr ""

#: ../../library/asyncio-dev.rst:371

msgid ""

"Therefore, if iteration begins before the event loop is created, the event "

"loop will not be able to add the generator to its list of active generators "

"because the hooks are set after the generator attempts to call them. "

"Consequently, the event loop will not be able to terminate the generator if "

"necessary."

msgstr ""

#: ../../library/asyncio-dev.rst:377

msgid "Consider the following example::"

msgstr "次に示す例について考えてみてください。::"

#: ../../library/asyncio-dev.rst:379

msgid ""

"import asyncio\n"

"\n"

"async def agenfn():\n"

" try:\n"

" yield 10\n"

" finally:\n"

" await asyncio.sleep(0)\n"

"\n"

"\n"

"with asyncio.Runner() as runner:\n"

" agen = agenfn()\n"

" print(runner.run(anext(agen)))\n"

" del agen"

msgstr ""

#: ../../library/asyncio-dev.rst:395

msgid ""

"10\n"

"Exception ignored while closing generator <async_generator object agenfn at "

"0x000002F71CD10D70>:\n"

"Traceback (most recent call last):\n"

" File \"example.py\", line 13, in <module>\n"

" del agen\n"

" ^^^^\n"

"RuntimeError: async generator ignored GeneratorExit"

msgstr ""

#: ../../library/asyncio-dev.rst:403

msgid "This example can be fixed as follows::"

msgstr ""

#: ../../library/asyncio-dev.rst:405

msgid ""

"import asyncio\n"

"\n"

"async def agenfn():\n"

" try:\n"

" yield 10\n"

" finally:\n"

" await asyncio.sleep(0)\n"

"\n"

"async def main():\n"

" agen = agenfn()\n"

" print(await anext(agen))\n"

" del agen\n"

"\n"

"asyncio.run(main())"

msgstr ""

#: ../../library/asyncio-dev.rst:422

msgid "Avoid concurrent iteration and closure of the same generator"

msgstr ""

#: ../../library/asyncio-dev.rst:424

msgid ""

"Async generators may be reentered while another :meth:`~agen.__anext__` / :"

"meth:`~agen.athrow` / :meth:`~agen.aclose` call is in progress. This may "

"lead to an inconsistent state of the async generator and can cause errors."

msgstr ""

#: ../../library/asyncio-dev.rst:429

msgid "Let's consider the following example::"

msgstr ""

#: ../../library/asyncio-dev.rst:431

msgid ""

"import asyncio\n"

"\n"

"async def consumer():\n"

" for idx in range(100):\n"

" await asyncio.sleep(0)\n"

" message = yield idx\n"

" print('received', message)\n"

"\n"

"async def amain():\n"

" agenerator = consumer()\n"

" await agenerator.asend(None)\n"

"\n"

" fa = asyncio.create_task(agenerator.asend('A'))\n"

" fb = asyncio.create_task(agenerator.asend('B'))\n"

" await fa\n"

" await fb\n"

"\n"

"asyncio.run(amain())"

msgstr ""

#: ../../library/asyncio-dev.rst:452

msgid ""

"received A\n"

"Traceback (most recent call last):\n"

" File \"test.py\", line 38, in <module>\n"

" asyncio.run(amain())\n"

" ~~~~~~~~~~~^^^^^^^^^\n"

" File \"Lib/asyncio/runners.py\", line 204, in run\n"

" return runner.run(main)\n"

" ~~~~~~~~~~^^^^^^\n"

" File \"Lib/asyncio/runners.py\", line 127, in run\n"

" return self._loop.run_until_complete(task)\n"

" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^\n"

" File \"Lib/asyncio/base_events.py\", line 719, in run_until_complete\n"

" return future.result()\n"

" ~~~~~~~~~~~~~^^\n"

" File \"test.py\", line 36, in amain\n"

" await fb\n"

"RuntimeError: anext(): asynchronous generator is already running"

msgstr ""

#: ../../library/asyncio-dev.rst:471

msgid ""

"Therefore, it is recommended to avoid using asynchronous generators in "

"parallel tasks or across multiple event loops."

msgstr ""