asyncio-dev.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Alireza Shabani (Revisto) <theRevisto@gmail.com>, 2025
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.14\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-09-21 11:59+0000\n"
"PO-Revision-Date: 2026-09-21 13:24+0330\n"
"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"
"Language-Team: Persian (https://github.com/python/python-docs-fa/)\n"
"Language: fa\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Poedit 3.6\n"

msgid "Developing with asyncio"
msgstr "توسعه با asyncio"

msgid "Asynchronous programming is different from classic \"sequential\" programming."
msgstr "برنامه‌نویسی ناهمگام با برنامه‌نویسی «ترتیبی» کلاسیک متفاوت است."

msgid "This page lists common mistakes and traps and explains how to avoid them."
msgstr "این صفحه، اشتباهات و تله‌های رایج را فهرست می‌کند و نحوه‌ی اجتناب از آن‌ها را توضیح می‌دهد."

msgid "Debug Mode"
msgstr "حالت اشکال‌زدایی"

msgid "By default asyncio runs in production mode.  In order to ease the development asyncio has a *debug mode*."
msgstr "به‌طور پیش‌فرض، asyncio در حالت تولید اجرا می‌شود. برای سهولت در توسعه، asyncio یک *حالت اشکال‌زدایی* دارد."

msgid "There are several ways to enable asyncio debug mode:"
msgstr "راه‌های متعددی برای فعال کردن حالت اشکال‌زدایی asyncio وجود دارد:"

msgid "Setting the :envvar:`PYTHONASYNCIODEBUG` environment variable to ``1``."
msgstr "تنظیم متغیر محیطی :envvar:`PYTHONASYNCIODEBUG` روی ``1``."

msgid "Using the :ref:`Python Development Mode <devmode>`."
msgstr "استفاده از :ref:`حالت توسعه پایتون <devmode>`."

msgid "Passing ``debug=True`` to :func:`asyncio.run`."
msgstr "ارسال ``debug=True`` به :func:`asyncio.run`."

msgid "Calling :meth:`loop.set_debug`."
msgstr "فراخوانی :meth:`loop.set_debug`."

msgid "In addition to enabling the debug mode, consider also:"
msgstr "علاوه بر فعال کردن حالت اشکال‌زدایی، این موارد را نیز در نظر داشته باشید:"

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 logger <asyncio-logger>` روی :py:const:`logging.DEBUG`، می‌توان برای مثال قطعه‌کد زیر را در زمان راه‌اندازی برنامه اجرا کرد::"

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

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`` است."

msgid "When the debug mode is enabled:"
msgstr "هنگامی که حالت اشکال‌زدایی فعال است:"

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 "بسیاری از APIهای asyncio که غیرایمن از نظر نخ هستند (مانند متدهای :meth:`loop.call_soon` و :meth:`loop.call_at`)، در صورت فراخوانی از یک نخ نادرست، استثنایی را پرتاب می‌کنند."

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 بیش از حد طول بکشد، ثبت می‌شود."

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 "کال‌بک‌هایی که بیش از ۱۰۰ میلی‌ثانیه طول می‌کشند، ثبت می‌شوند. ویژگی :attr:`loop.slow_callback_duration` را می‌توان برای تنظیم حداقل مدت زمان اجرا بر حسب ثانیه که «کند» محسوب می‌شود، استفاده کرد."

msgid "Concurrency and Multithreading"
msgstr "هم‌روندی و چندنخی"

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 "یک حلقه رویداد در یک نخ (معمولاً نخ اصلی) اجرا می‌شود و تمام کال‌بک‌ها و Taskها را در نخ خود اجرا می‌کند. در حالی که یک Task در حلقه رویداد در حال اجرا است، هیچ Task دیگری نمی‌تواند در همان نخ اجرا شود. هنگامی که یک Task یک عبارت ``await`` را اجرا می‌کند، Task در حال اجرا معلق می‌شود و حلقه رویداد Task بعدی را اجرا می‌کند."

msgid "To schedule a :term:`callback` from another OS thread, the :meth:`loop.call_soon_threadsafe` method should be used. Example::"
msgstr "برای زمان‌بندی یک :term:`کال‌بک <callback>` از یک نخ دیگر سیستم‌عامل، باید از متد :meth:`loop.call_soon_threadsafe` استفاده شود. مثال::"

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

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 ایمن از نظر نخ نیستند، که این موضوع معمولاً مشکلی ایجاد نمی‌کند، مگر اینکه کدی از خارج از یک Task یا کال‌بک با آن‌ها کار کند. اگر لازم باشد چنین کدی یک API سطح پایین asyncio را فراخوانی کند، باید از متد :meth:`loop.call_soon_threadsafe` استفاده شود، برای مثال::"

msgid "loop.call_soon_threadsafe(fut.cancel)"
msgstr "loop.call_soon_threadsafe(fut.cancel)"

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 "برای زمان‌بندی یک شیء هم‌روال از یک نخ سیستم‌عاملی دیگر، باید از تابع :func:`run_coroutine_threadsafe` استفاده شود. این تابع یک :class:`concurrent.futures.Future` برای دسترسی به نتیجه برمی‌گرداند::"

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 ""
"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()"

msgid "To handle signals the event loop must be run in the main thread."
msgstr "برای مدیریت سیگنال‌ها، حلقه رویداد باید در نخ اصلی اجرا شود."

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 "می‌توان از متد :meth:`loop.run_in_executor` به‌همراه یک :class:`concurrent.futures.ThreadPoolExecutor` یا :class:`~concurrent.futures.InterpreterPoolExecutor` برای اجرای کد مسدودکننده در یک نخ سیستم‌عامل دیگر، بدون مسدود کردن نخ سیستم‌عاملی که حلقه رویداد در آن اجرا می‌شود، استفاده کرد."

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هایی را فهرست می‌کند که می‌توانند بدون مسدود کردن حلقه رویداد، از پایپ‌ها بخوانند و توصیف‌گرهای پرونده را پایش کنند. علاوه بر این، APIهای :ref:`زیرفرایند <asyncio-subprocess>` در asyncio راهی برای شروع یک فرایند و برقراری ارتباط با آن از حلقه رویداد فراهم می‌کنند. در نهایت، متد یادشده :meth:`loop.run_in_executor` را می‌توان نیز با یک :class:`concurrent.futures.ProcessPoolExecutor` برای اجرای کد در یک فرایند دیگر به‌کار برد."

msgid "Running Blocking Code"
msgstr "اجرای کد مسدودکننده"

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-bound) نباید به‌صورت مستقیم فراخوانی شود. برای مثال، اگر تابعی یک محاسبه‌ی سنگین از نظر CPU را به مدت ۱ ثانیه انجام دهد، تمام Taskهای همزمان asyncio و عملیات‌های IO به اندازه‌ی ۱ ثانیه به تأخیر می‌افتند."

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 "می‌توان از یک اجراکننده (executor) برای اجرای یک تکلیف در نخی دیگر، از جمله در مفسری دیگر، یا حتی در فرایندی دیگر استفاده کرد تا از مسدود شدن نخ سیستم‌عاملِ حلقه رویداد جلوگیری شود. برای جزئیات بیشتر، متد :meth:`loop.run_in_executor` را ببینید."

msgid "Logging"
msgstr "گزارش‌گیری"

msgid "asyncio uses the :mod:`logging` module and all logging is performed via the ``\"asyncio\"`` logger."
msgstr "asyncio از ماژول :mod:`logging` استفاده می‌کند و تمام گزارش‌گیری از طریق گزارش‌گیر ``\"asyncio\"`` انجام می‌شود."

msgid "The default log level is :py:const:`logging.INFO`, which can be easily adjusted::"
msgstr "سطح گزارش پیش‌فرض :py:const:`logging.INFO` است که به‌سادگی می‌توان آن را تنظیم کرد::"

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

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 "گزارش‌گیری شبکه می‌تواند حلقه رویداد را مسدود کند. توصیه می‌شود برای پردازش گزارش‌ها از یک نخ جداگانه استفاده کنید یا از ورودی/خروجی غیرمسدودکننده (non-blocking IO) استفاده کنید. برای مثال، :ref:`blocking-handlers` را ببینید."

msgid "Detect never-awaited coroutines"
msgstr "تشخیص هم‌روال‌هایی که هرگز await نشده‌اند"

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()`` به جای ``await coro()``) یا هم‌روال با :meth:`asyncio.create_task` زمان‌بندی نمی‌شود، asyncio یک :exc:`RuntimeWarning` را نشان میدهد::"

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 ""
"import asyncio\n"
"\n"
"async def test():\n"
"    print(\"never scheduled\")\n"
"\n"
"async def main():\n"
"    test()\n"
"\n"
"asyncio.run(main())"

msgid "Output::"
msgstr "خروجی::"

msgid ""
"test.py:7: RuntimeWarning: coroutine 'test' was never awaited\n"
"  test()"
msgstr ""
"test.py:7: RuntimeWarning: coroutine 'test' was never awaited\n"
"  test()"

msgid "Output in debug mode::"
msgstr "خروجی در حالت اشکال‌زدایی::"

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 ""
"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()"

msgid "The usual fix is to either await the coroutine or call the :meth:`asyncio.create_task` function::"
msgstr "راه‌حل معمول این است که یا هم‌روال را await کنید یا تابع :meth:`asyncio.create_task` را فراخوانی کنید::"

msgid ""
"async def main():\n"
"    await test()"
msgstr ""
"async def main():\n"
"    await test()"

msgid "Detect never-retrieved exceptions"
msgstr "تشخیص استثناهای هرگز بازیابی‌نشده"

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 هرگز await نشود، استثنا هرگز به کد کاربر منتقل نمی‌شود. در این حالت، asyncio هنگامی که شیء Future زباله‌روبی می‌شود، یک پیام گزارش نشان می‌دهد."

msgid "Example of an unhandled exception::"
msgstr "مثالی از یک استثنای مدیریت‌نشده::"

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 ""
"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())"

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 ""
"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"

msgid ":ref:`Enable the debug mode <asyncio-debug-mode>` to get the traceback where the task was created::"
msgstr ":ref:`حالت اشکال‌زدایی را فعال کنید <asyncio-debug-mode>` تا ردگیری پشته‌ی محل ایجاد وظیفه را دریافت کنید::"

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

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 ""
"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"

msgid "Asynchronous generators best practices"
msgstr "بهترین شیوه‌های تولیدگرهای ناهمگام"

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 "نوشتن کد asyncio صحیح و کارآمد، نیازمند آگاهی از برخی دام‌ها است. این بخش بهترین شیوه‌های ضروری را شرح می‌دهد که می‌تواند شما را از ساعت‌ها اشکال‌زدایی نجات دهد."

msgid "Close asynchronous generators explicitly"
msgstr "تولیدگرهای ناهمگام را به‌صورت صریح ببندید"

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 "توصیه می‌شود :term:`تولیدگر ناهمگام <asynchronous generator iterator>` را به‌صورت دستی ببندید. اگر یک تولیدگر زودتر خارج شود، برای مثال، به دلیل پرتاب شدن یک استثنا در بدنه‌ی یک حلقه ``async for``، ممکن است کد پاک‌سازی ناهمگام آن در زمینه‌ای غیرمنتظره اجرا شود. این ممکن است پس از کامل شدن وظایفی که به آن‌ها وابسته است، یا در حین خاموش شدن حلقه‌ی رویداد، هنگامی که قلاب زباله‌روبی تولیدگر ناهمگام فراخوانی می‌شود، رخ دهد."

msgid "To avoid this, explicitly close the generator by calling its :meth:`~agen.aclose` method, or use the :func:`contextlib.aclosing` context manager::"
msgstr "برای جلوگیری از این موضوع، تولیدگر را با فراخوانی متد :meth:`~agen.aclose` آن به‌صراحت ببندید، یا از مدیر زمینه :func:`contextlib.aclosing` استفاده کنید::"

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 ""
"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())"

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 "همان‌طور که در بالا ذکر شد، کد پاک‌سازی برای این تولیدگرهای ناهمگام به تعویق می‌افتد. مثال زیر نشان می‌دهد که نهایی‌سازی یک تولیدگر ناهمگام می‌تواند با ترتیبی غیرمنتظره رخ دهد::"

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) # imitate 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 ""
"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) # imitate 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())"

msgid "For this example, we get the following output::"
msgstr "برای این مثال، خروجی زیر را دریافت می‌کنیم::"

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 ""
"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"

msgid "The ``cursor()`` asynchronous generator was finalized before the ``rows`` generator - an unexpected behavior."
msgstr "تولیدگر ناهمگام ``cursor()`` پیش از تولیدگر ``rows`` نهایی شد - رفتاری غیرمنتظره."

msgid "The example can be fixed by explicitly closing the ``cursor`` and ``rows`` async-generators::"
msgstr "این مثال را می‌توان با بستن صریح تولیدگرهای ناهمگام ``cursor`` و ``rows`` اصلاح کرد::"

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 ""
"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"

msgid "Create asynchronous generators only when the event loop is running"
msgstr "تولیدگرهای ناهمگام را فقط زمانی ایجاد کنید که حلقه رویداد در حال اجرا است"

msgid "It is recommended to create :term:`asynchronous generators <asynchronous generator iterator>` only after the event loop has been created."
msgstr "توصیه می‌شود :term:`تولیدگرهای ناهمگام <asynchronous generator iterator>` تنها پس از ایجاد حلقه رویداد ایجاد شوند."

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 "برای اطمینان از اینکه تولیدگرهای ناهمگام به‌طور قابل‌اطمینان بسته شوند، حلقه رویداد از تابع :func:`sys.set_asyncgen_hooks` برای ثبت توابع کال‌بک استفاده می‌کند. این کال‌بک‌ها فهرست تولیدگرهای ناهمگام در حال اجرا را به‌روزرسانی می‌کنند تا آن را در وضعیت سازگار نگه دارند."

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 "هنگامی که تابع :meth:`loop.shutdown_asyncgens() <asyncio.loop.shutdown_asyncgens>` فراخوانی می‌شود، تولیدگرهای در حال اجرا به‌صورت مناسب متوقف می‌شوند و فهرست پاک می‌شود."

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 "تولیدگر ناهمگام، قلاب سیستم مربوطه را در نخستین تکرار خود فراخوانی می‌کند. در همان زمان، تولیدگر ثبت می‌کند که قلاب فراخوانی شده است و دیگر آن را فراخوانی نمی‌کند."

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 "بنابراین، اگر تکرار پیش از ایجاد حلقه رویداد آغاز شود، حلقه رویداد نمی‌تواند تولیدگر را به فهرست تولیدگرهای فعال خود اضافه کند، زیرا قلاب‌ها پس از تلاش تولیدگر برای فراخوانی آن‌ها تنظیم می‌شوند. در نتیجه، حلقه رویداد در صورت لزوم نمی‌تواند تولیدگر را خاتمه دهد."

msgid "Consider the following example::"
msgstr "مثال زیر را در نظر بگیرید::"

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 ""
"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"

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 ""
"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"

msgid "This example can be fixed as follows::"
msgstr "این مثال را می‌توان به‌صورت زیر اصلاح کرد::"

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 ""
"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())"

msgid "Avoid concurrent iteration and closure of the same generator"
msgstr "از پیمایش و بستن همزمان یک تولیدگر یکسان خودداری کنید"

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 "تولیدگرهای ناهمگام ممکن است در حالی که فراخوانی دیگری از :meth:`~agen.__anext__` یا :meth:`~agen.athrow` یا :meth:`~agen.aclose` در حال انجام است، دوباره وارد شوند. این امر ممکن است به وضعیت ناسازگار تولیدگر ناهمگام منجر شود و باعث ایجاد خطا شود."

msgid "Let's consider the following example::"
msgstr "مثال زیر را در نظر بگیرید::"

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 ""
"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())"

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 ""
"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"

msgid "Therefore, it is recommended to avoid using asynchronous generators in parallel tasks or across multiple event loops."
msgstr "بنابراین، توصیه می‌شود از استفاده از تولیدگرهای ناهمگام در وظایف موازی یا بین چندین حلقه رویداد خودداری کنید."