asyncio-task.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:27+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 "Coroutines and tasks"
msgstr "هم‌روال‌ها و وظایف"

msgid "This section outlines high-level asyncio APIs to work with coroutines and Tasks."
msgstr "این بخش، مروری بر APIهای سطح بالای asyncio برای کار با هم‌روال‌ها و وظیفه‌ها  ارائه می‌دهد."

msgid "Coroutines"
msgstr "هم‌روال‌ها"

msgid "**Source code:** :source:`Lib/asyncio/coroutines.py`"
msgstr "**کد منبع:** :source:`Lib/asyncio/coroutines.py`"

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 prints \"hello\", waits 1 second, and then prints \"world\"::"
msgstr "تعریف :term:`هم‌روال‌ها <coroutine>` با سینتکس async/await، روش ترجیحی برای نوشتن برنامه‌های asyncio است.  برای مثال، قطعه‌کد زیر \"hello\" را چاپ می‌کند، ۱ ثانیه منتظر می‌ماند، و سپس \"world\" را چاپ می‌کند::"

msgid ""
">>> import asyncio\n"
"\n"
">>> async def main():\n"
"...     print('hello')\n"
"...     await asyncio.sleep(1)\n"
"...     print('world')\n"
"\n"
">>> asyncio.run(main())\n"
"hello\n"
"world"
msgstr ""
">>> import asyncio\n"
"\n"
">>> async def main():\n"
"...     print('hello')\n"
"...     await asyncio.sleep(1)\n"
"...     print('world')\n"
"\n"
">>> asyncio.run(main())\n"
"hello\n"
"world"

msgid "Note that simply calling a coroutine will not schedule it to be executed::"
msgstr "توجه داشته باشید که صرفاً فراخوانی یک هم‌روال، آن را برای اجرا زمان‌بندی نمی‌کند::"

msgid ""
">>> main()\n"
"<coroutine object main at 0x1053bb7c8>"
msgstr ""
">>> main()\n"
"<coroutine object main at 0x1053bb7c8>"

msgid "To actually run a coroutine, asyncio provides the following mechanisms:"
msgstr "برای اجرای واقعی یک هم‌روال، asyncio سازوکارهای زیر را فراهم می‌کند:"

msgid "The :func:`asyncio.run` function to run the top-level entry point \"main()\" function (see the above example.)"
msgstr "تابع :func:`asyncio.run` برای اجرای تابع نقطه ورود سطح بالا \"main()\" (مثال بالا را ببینید.)"

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 "در انتظار یک هم‌روال. قطعه‌کد زیر پس از انتظار برای ۱ ثانیه، «hello» را چاپ می‌کند و سپس «world» را پس از انتظار برای ۲ ثانیه‌ی *دیگر* چاپ خواهد کرد::"

msgid ""
"import asyncio\n"
"import time\n"
"\n"
"async def say_after(delay, what):\n"
"    await asyncio.sleep(delay)\n"
"    print(what)\n"
"\n"
"async def main():\n"
"    print(f\"started at {time.strftime('%X')}\")\n"
"\n"
"    await say_after(1, 'hello')\n"
"    await say_after(2, 'world')\n"
"\n"
"    print(f\"finished at {time.strftime('%X')}\")\n"
"\n"
"asyncio.run(main())"
msgstr ""
"import asyncio\n"
"import time\n"
"\n"
"async def say_after(delay, what):\n"
"    await asyncio.sleep(delay)\n"
"    print(what)\n"
"\n"
"async def main():\n"
"    print(f\"started at {time.strftime('%X')}\")\n"
"\n"
"    await say_after(1, 'hello')\n"
"    await say_after(2, 'world')\n"
"\n"
"    print(f\"finished at {time.strftime('%X')}\")\n"
"\n"
"asyncio.run(main())"

msgid "Expected output::"
msgstr "خروجی مورد انتظار::"

msgid ""
"started at 17:13:52\n"
"hello\n"
"world\n"
"finished at 17:13:55"
msgstr ""
"started at 17:13:52\n"
"hello\n"
"world\n"
"finished at 17:13:55"

msgid "The :func:`asyncio.create_task` function to run coroutines concurrently as asyncio :class:`Tasks <Task>`."
msgstr "تابع :func:`asyncio.create_task` برای اجرای همزمان هم‌روال‌ها به‌عنوان :class:`Tasks <Task>` در asyncio."

msgid "Let's modify the above example and run two ``say_after`` coroutines *concurrently*::"
msgstr "بیایید مثال بالا را تغییر دهیم و دو هم‌روال ``say_after`` را *همزمان* اجرا کنیم::"

msgid ""
"async def main():\n"
"    task1 = asyncio.create_task(\n"
"        say_after(1, 'hello'))\n"
"\n"
"    task2 = asyncio.create_task(\n"
"        say_after(2, 'world'))\n"
"\n"
"    print(f\"started at {time.strftime('%X')}\")\n"
"\n"
"    # Wait until both tasks are completed (should take\n"
"    # around 2 seconds.)\n"
"    await task1\n"
"    await task2\n"
"\n"
"    print(f\"finished at {time.strftime('%X')}\")"
msgstr ""
"async def main():\n"
"    task1 = asyncio.create_task(\n"
"        say_after(1, 'hello'))\n"
"\n"
"    task2 = asyncio.create_task(\n"
"        say_after(2, 'world'))\n"
"\n"
"    print(f\"started at {time.strftime('%X')}\")\n"
"\n"
"    # Wait until both tasks are completed (should take\n"
"    # around 2 seconds.)\n"
"    await task1\n"
"    await task2\n"
"\n"
"    print(f\"finished at {time.strftime('%X')}\")"

msgid "Note that expected output now shows that the snippet runs 1 second faster than before::"
msgstr "توجه داشته باشید که خروجی مورد انتظار اکنون نشان می‌دهد که قطعه‌کد ۱ ثانیه سریع‌تر از قبل اجرا می‌شود::"

msgid ""
"started at 17:14:32\n"
"hello\n"
"world\n"
"finished at 17:14:34"
msgstr ""
"started at 17:14:32\n"
"hello\n"
"world\n"
"finished at 17:14:34"

msgid "The :class:`asyncio.TaskGroup` class provides a more modern alternative to :func:`create_task`. Using this API, the last example becomes::"
msgstr "کلاس :class:`asyncio.TaskGroup` جایگزین مدرن‌تری برای :func:`create_task` فراهم می‌کند. با استفاده از این API، آخرین مثال به‌شکل زیر درمی‌آید::"

msgid ""
"async def main():\n"
"    async with asyncio.TaskGroup() as tg:\n"
"        task1 = tg.create_task(\n"
"            say_after(1, 'hello'))\n"
"\n"
"        task2 = tg.create_task(\n"
"            say_after(2, 'world'))\n"
"\n"
"        print(f\"started at {time.strftime('%X')}\")\n"
"\n"
"    # The await is implicit when the context manager exits.\n"
"\n"
"    print(f\"finished at {time.strftime('%X')}\")"
msgstr ""
"async def main():\n"
"    async with asyncio.TaskGroup() as tg:\n"
"        task1 = tg.create_task(\n"
"            say_after(1, 'hello'))\n"
"\n"
"        task2 = tg.create_task(\n"
"            say_after(2, 'world'))\n"
"\n"
"        print(f\"started at {time.strftime('%X')}\")\n"
"\n"
"    # The await is implicit when the context manager exits.\n"
"\n"
"    print(f\"finished at {time.strftime('%X')}\")"

msgid "The timing and output should be the same as for the previous version."
msgstr "زمان‌بندی و خروجی باید مانند نسخه‌ی پیشین یکسان باشند."

msgid ":class:`asyncio.TaskGroup`."
msgstr ":class:`asyncio.TaskGroup`."

msgid "Awaitables"
msgstr "Awaitableها"

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 "می‌گوییم که یک شیء در صورتی یک شیء **awaitable** است که بتوان از آن در یک عبارت :keyword:`await` استفاده کرد. بسیاری از APIهای asyncio برای پذیرش awaitableها طراحی شده‌اند."

msgid "There are three main types of *awaitable* objects: **coroutines**, **Tasks**, and **Futures**."
msgstr "سه نوع اصلی از اشیای *awaitable* وجود دارد: **هم‌روال‌ها**، **Taskها** و **Futureها**."

msgid "Python coroutines are *awaitables* and therefore can be awaited from other coroutines::"
msgstr "هم‌روال‌های پایتون *awaitables* هستند و بنابراین می‌توان آن‌ها را از هم‌روال‌های دیگر await کرد::"

msgid ""
"import asyncio\n"
"\n"
"async def nested():\n"
"    return 42\n"
"\n"
"async def main():\n"
"    # Nothing happens if we just call \"nested()\".\n"
"    # A coroutine object is created but not awaited,\n"
"    # so it *won't run at all*.\n"
"    nested()  # will raise a \"RuntimeWarning\".\n"
"\n"
"    # Let's do it differently now and await it:\n"
"    print(await nested())  # will print \"42\".\n"
"\n"
"asyncio.run(main())"
msgstr ""
"import asyncio\n"
"\n"
"async def nested():\n"
"    return 42\n"
"\n"
"async def main():\n"
"    # Nothing happens if we just call \"nested()\".\n"
"    # A coroutine object is created but not awaited,\n"
"    # so it *won't run at all*.\n"
"    nested()  # will raise a \"RuntimeWarning\".\n"
"\n"
"    # Let's do it differently now and await it:\n"
"    print(await nested())  # will print \"42\".\n"
"\n"
"asyncio.run(main())"

msgid "In this documentation the term \"coroutine\" can be used for two closely related concepts:"
msgstr "در این مستندات، اصطلاح «هم‌روال» می‌تواند برای دو مفهوم بسیار مرتبط به‌کار رود:"

msgid "a *coroutine function*: an :keyword:`async def` function;"
msgstr "یک *تابع هم‌روال*: یک تابع :keyword:`async def`؛"

msgid "a *coroutine object*: an object returned by calling a *coroutine function*."
msgstr "یک *شیء هم‌روال*: شیءای که با فراخوانی یک *تابع هم‌روال* برگردانده می‌شود."

msgid "Tasks"
msgstr "وظایف"

msgid "*Tasks* are used to schedule coroutines *concurrently*."
msgstr "*وظایف* برای زمان‌بندی هم‌روال‌ها به‌صورت همزمان استفاده می‌شوند."

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

msgid ""
"import asyncio\n"
"\n"
"async def nested():\n"
"    return 42\n"
"\n"
"async def main():\n"
"    # Schedule nested() to run soon concurrently\n"
"    # with \"main()\".\n"
"    task = asyncio.create_task(nested())\n"
"\n"
"    # \"task\" can now be used to cancel \"nested()\", or\n"
"    # can simply be awaited to wait until it is complete:\n"
"    await task\n"
"\n"
"asyncio.run(main())"
msgstr ""
"import asyncio\n"
"\n"
"async def nested():\n"
"    return 42\n"
"\n"
"async def main():\n"
"    # Schedule nested() to run soon concurrently\n"
"    # with \"main()\".\n"
"    task = asyncio.create_task(nested())\n"
"\n"
"    # \"task\" can now be used to cancel \"nested()\", or\n"
"    # can simply be awaited to wait until it is complete:\n"
"    await task\n"
"\n"
"asyncio.run(main())"

msgid "Futures"
msgstr "آینده‌نماها (Futures)"

msgid "A :class:`Future` is a special **low-level** awaitable object that represents an **eventual result** of an asynchronous operation."
msgstr ":class:`Future` یک شیء خاص **سطح پایین** قابل await (awaitable) است که نشان‌دهنده‌ی **نتیجه نهایی** یک عملیات ناهمگام است."

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 *await* می‌شود، به این معنا است که هم‌روال منتظر می‌ماند تا Future در جای دیگری حل شود."

msgid "Future objects in asyncio are needed to allow callback-based code to be used with async/await."
msgstr "اشیای Future در asyncio لازم هستند تا بتوان از کد مبتنی بر کال‌بک با async/await استفاده کرد."

msgid "Normally **there is no need** to create Future objects at the application level code."
msgstr "معمولاً **نیازی نیست** که اشیای Future را در کد سطح برنامه ایجاد کنید."

msgid "Future objects, sometimes exposed by libraries and some asyncio APIs, can be awaited::"
msgstr "اشیای Future را، که گاهی از طریق کتابخانه‌ها و برخی APIهای asyncio در دسترس قرار می‌گیرند، می‌توان await کرد::"

msgid ""
"async def main():\n"
"    await function_that_returns_a_future_object()\n"
"\n"
"    # this is also valid:\n"
"    await asyncio.gather(\n"
"        function_that_returns_a_future_object(),\n"
"        some_python_coroutine()\n"
"    )"
msgstr ""
"async def main():\n"
"    await function_that_returns_a_future_object()\n"
"\n"
"    # this is also valid:\n"
"    await asyncio.gather(\n"
"        function_that_returns_a_future_object(),\n"
"        some_python_coroutine()\n"
"    )"

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

msgid "Creating tasks"
msgstr "ایجاد وظایف"

msgid "**Source code:** :source:`Lib/asyncio/tasks.py`"
msgstr "**کد منبع:** :source:`Lib/asyncio/tasks.py`"

msgid "Wrap the *coro* :ref:`coroutine <coroutine>` into a :class:`Task` and schedule its execution.  Return the Task object."
msgstr ":ref:`هم‌روال <coroutine>` *coro* را در یک :class:`Task` قرار می‌دهد و اجرای آن را زمان‌بندی می‌کند. شیء Task را برمی‌گرداند."

msgid "The full function signature is largely the same as that of the :class:`Task` constructor (or factory) - all of the keyword arguments to this function are passed through to that interface."
msgstr "امضای کامل تابع تا حد زیادی مشابه سازنده‌ی :class:`Task` (یا کارخانه) است؛ تمام آرگومان‌های کلیدواژه‌ای این تابع به آن رابط منتقل می‌شوند."

msgid "An optional keyword-only *context* argument allows specifying a custom :class:`contextvars.Context` for the *coro* to run in. The current context copy is created when no *context* is provided."
msgstr "یک آرگومان اختیاری فقط کلیدواژه‌ای *context* به شما امکان می‌دهد یک :class:`contextvars.Context` سفارشی برای اجرای *coro* مشخص کنید. اگر *context* ارائه نشود، یک کپی از زمینه فعلی ایجاد می‌شود."

msgid "An optional keyword-only *eager_start* argument allows specifying if the task should execute eagerly during the call to create_task, or be scheduled later. If *eager_start* is not passed the mode set by :meth:`loop.set_task_factory` will be used."
msgstr "یک آرگومان اختیاری فقط کلیدواژه‌ای *eager_start* به شما امکان می‌دهد مشخص کنید که آیا وظیفهباید در حین فراخوانی create_task به‌صورت فوری اجرا شود یا بعداً زمان‌بندی شود. اگر *eager_start* ارسال نشود، حالت تنظیم‌شده توسط :meth:`loop.set_task_factory` استفاده خواهد شد."

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 "این وظیفه در حلقه‌ای که :func:`get_running_loop` برمی‌گرداند اجرا می‌شود؛ اگر حلقه‌ی در حال اجرا در نخ جاری وجود نداشته باشد، :exc:`RuntimeError` پرتاب می‌شود."

msgid ":meth:`asyncio.TaskGroup.create_task` is a new alternative leveraging structural concurrency; it allows for waiting for a group of related tasks with strong safety guarantees."
msgstr ":meth:`asyncio.TaskGroup.create_task` جایگزینی جدید است که از همروندی ساختاری بهره می‌گیرد؛ این امکان را فراهم می‌کند که با تضمین‌های نیرومند ایمنی، منتظر گروهی از وظایف مرتبط بمانید."

msgid "Save a reference to the result of this function, to avoid a task disappearing mid-execution. The event loop only keeps weak references to tasks. A task that isn't referenced elsewhere may get garbage collected at any time, even before it's done. For reliable \"fire-and-forget\" background tasks, gather them in a collection::"
msgstr "برای جلوگیری از ناپدید شدن یک وظیفه در میانه‌ی اجرا، یک ارجاع به نتیجه‌ی این تابع ذخیره کنید. حلقه‌ی رویداد تنها ارجاع‌های ضعیف به وظایف را نگه می‌دارد. وظیفه‌ای که در جای دیگری به آن ارجاع داده نشده است، ممکن است در هر زمانی زباله‌روبی شود، حتی پیش از آنکه به پایان برسد. برای وظایف پس‌زمینه‌ی قابل‌اطمینان از نوع «fire-and-forget»، آن‌ها را در یک مجموعه گردآوری کنید::"

msgid ""
"background_tasks = set()\n"
"\n"
"for i in range(10):\n"
"    task = asyncio.create_task(some_coro(param=i))\n"
"\n"
"    # Add task to the set. This creates a strong reference.\n"
"    background_tasks.add(task)\n"
"\n"
"    # To prevent keeping references to finished tasks forever,\n"
"    # make each task remove its own reference from the set after\n"
"    # completion:\n"
"    task.add_done_callback(background_tasks.discard)"
msgstr ""
"background_tasks = set()\n"
"\n"
"for i in range(10):\n"
"    task = asyncio.create_task(some_coro(param=i))\n"
"\n"
"    # Add task to the set. This creates a strong reference.\n"
"    background_tasks.add(task)\n"
"\n"
"    # To prevent keeping references to finished tasks forever,\n"
"    # make each task remove its own reference from the set after\n"
"    # completion:\n"
"    task.add_done_callback(background_tasks.discard)"

msgid "Note that this approach never awaits the tasks, so if a task fails, its exception is never retrieved and asyncio logs a \"Task exception was never retrieved\" message when the task is garbage collected.  To avoid this, use :class:`asyncio.TaskGroup` which keeps a strong reference to each task, awaits them and propagates their exceptions::"
msgstr "توجه داشته باشید که این رویکرد هرگز وظایف را await نمی‌کند، بنابراین اگر یک وظیفه شکست بخورد، استثنای آن هرگز بازیابی نمی‌شود و asyncio پیامی \"Task exception was never retrieved\" را ثبت می‌کند وقتی که وظیفه زباله‌روب می‌شود.  برای جلوگیری از این، از :class:`asyncio.TaskGroup` استفاده کنید که یک ارجاع قوی به هر وظیفه نگه می‌دارد، آن‌ها را await می‌کند و استثنای آن‌ها را انتقال می‌دهد::"

msgid ""
"async with asyncio.TaskGroup() as tg:\n"
"    for i in range(10):\n"
"        tg.create_task(some_coro(param=i))"
msgstr ""
"async with asyncio.TaskGroup() as tg:\n"
"    for i in range(10):\n"
"        tg.create_task(some_coro(param=i))"

msgid "Added the *name* parameter."
msgstr "پارامتر *name* افزوده شد."

msgid "Added the *context* parameter."
msgstr "پارامتر *context* افزوده شد."

msgid "Added the *eager_start* parameter by passing on all *kwargs*."
msgstr "پارامتر *eager_start* با ارسال تمام *kwargs* افزوده شد."

msgid "Task cancellation"
msgstr "لغو وظیفه"

msgid "Tasks can easily and safely be cancelled. When a task is cancelled, :exc:`asyncio.CancelledError` will be raised in the task at the next opportunity."
msgstr "وظایف را می‌توان به‌آسانی و به‌صورت امن لغو کرد. هنگامی که یک وظیفه لغو می‌شود، :exc:`asyncio.CancelledError` در اولین فرصت در آن وظیفه پرتاب خواهد شد."

msgid "It is recommended that coroutines use ``try/finally`` blocks to robustly perform clean-up logic. In case :exc:`asyncio.CancelledError` is explicitly caught, it should generally be propagated when clean-up is complete. :exc:`asyncio.CancelledError` directly subclasses :exc:`BaseException` so most code will not need to be aware of it."
msgstr "توصیه می‌شود هم‌روال‌ها از بلوک‌های ``try/finally`` برای انجام منطق پاک‌سازی به‌صورت مقاوم استفاده کنند. در صورتی که :exc:`asyncio.CancelledError` به‌طور صریح گرفته شود، معمولاً باید پس از تکمیل پاک‌سازی انتشار یابد. :exc:`asyncio.CancelledError` مستقیماً زیرکلاس :exc:`BaseException` است، بنابراین بیشتر کدها نیازی به آگاهی از آن نخواهند داشت."

msgid "The asyncio components that enable structured concurrency, like :class:`asyncio.TaskGroup` and :func:`asyncio.timeout`, are implemented using cancellation internally and might misbehave if a coroutine swallows :exc:`asyncio.CancelledError`. Similarly, user code should not generally call :meth:`uncancel <asyncio.Task.uncancel>`. However, in cases when suppressing :exc:`asyncio.CancelledError` is truly desired, it is necessary to also call ``uncancel()`` to completely remove the cancellation state."
msgstr "کامپوننت‌های asyncio که هم‌روندی ساختاریافته را فراهم می‌کنند، مانند :class:`asyncio.TaskGroup` و :func:`asyncio.timeout`، به‌صورت داخلی با استفاده از لغو پیاده‌سازی شده‌اند و ممکن است در صورتی که یک هم‌روال :exc:`asyncio.CancelledError` را نادیده بگیرد، رفتار نادرستی داشته باشند. به‌طور مشابه، کد کاربر عموماً نباید :meth:`uncancel <asyncio.Task.uncancel>` را فراخوانی کند. با این حال، در مواردی که سرکوب :exc:`asyncio.CancelledError` واقعاً مطلوب باشد، لازم است ``uncancel()`` نیز فراخوانی شود تا وضعیت لغو به‌طور کامل حذف شود."

msgid "Task groups"
msgstr "گروه‌های وظیفه (Task groups)"

msgid "Task groups combine a task creation API with a convenient and reliable way to wait for all tasks in the group to finish."
msgstr "گروه‌های وظیفه، یک API برای ایجاد وظیفه را با روشی راحت و مطمئن برای منتظر ماندن تا پایان‌یافتن تمام وظایف گروه ترکیب می‌کنند."

msgid "An :ref:`asynchronous context manager <async-context-managers>` holding a group of tasks. Tasks can be added to the group using :meth:`create_task`. All tasks are awaited when the context manager exits."
msgstr "یک :ref:`مدیر زمینه ناهمگام <async-context-managers>` که گروهی از وظایف را نگه می‌دارد. می‌توان وظایف را با استفاده از :meth:`create_task` به گروه اضافه کرد. هنگام خروج مدیر زمینه، همه وظایف await می‌شوند."

msgid "Create a task in this task group. The signature matches that of :func:`asyncio.create_task`. If the task group is inactive (e.g. not yet entered, already finished, or in the process of shutting down), we will close the given ``coro`` and raise :exc:`RuntimeError`."
msgstr "یک وظیفه در این گروه وظیفه ایجاد کنید. امضا با :func:`asyncio.create_task` مطابقت دارد. اگر گروه وظیفه غیرفعال باشد (مثلا هنوز وارد نشده، قبلاً تمام شده، یا در فرآیند خاموش شدن)، ما ``coro`` داده شده را می‌بندیم و :exc:`RuntimeError` را پرتاب می‌کنیم."

msgid "Close the given coroutine if the task group is not active."
msgstr "اگر گروه وظیفه فعال نیست، هم‌روال داده‌شده را ببندید."

msgid "Passes on all *kwargs* to :meth:`loop.create_task`"
msgstr "تمام *kwargs* را به :meth:`loop.create_task` منتقل می‌کند"

msgid "Example::"
msgstr "مثال::"

msgid ""
"async def main():\n"
"    async with asyncio.TaskGroup() as tg:\n"
"        task1 = tg.create_task(some_coro(...))\n"
"        task2 = tg.create_task(another_coro(...))\n"
"    print(f\"Both tasks have completed now: {task1.result()}, {task2.result()}\")"
msgstr ""
"async def main():\n"
"    async with asyncio.TaskGroup() as tg:\n"
"        task1 = tg.create_task(some_coro(...))\n"
"        task2 = tg.create_task(another_coro(...))\n"
"    print(f\"Both tasks have completed now: {task1.result()}, {task2.result()}\")"

msgid "The ``async with`` statement will wait for all tasks in the group to finish. While waiting, new tasks may still be added to the group (for example, by passing ``tg`` into one of the coroutines and calling ``tg.create_task()`` in that coroutine). Once the last task has finished and the ``async with`` block is exited, no new tasks may be added to the group."
msgstr "دستور ``async with`` منتظر می‌ماند تا تمام وظایف گروه به پایان برسند. در حین انتظار، همچنان ممکن است وظایف جدیدی به گروه اضافه شوند (برای مثال، با پاس دادن ``tg`` به یکی از هم‌روال‌ها و فراخوانی ``tg.create_task()`` در آن هم‌روال). پس از پایان آخرین وظیفه و خروج از بلوک ``async with``، دیگر نمی‌توان وظیفه جدیدی به گروه اضافه کرد."

msgid "The first time any of the tasks belonging to the group fails with an exception other than :exc:`asyncio.CancelledError`, the remaining tasks in the group are cancelled. No further tasks can then be added to the group. At this point, if the body of the ``async with`` statement is still active (i.e., :meth:`~object.__aexit__` hasn't been called yet), the task directly containing the ``async with`` statement is also cancelled. The resulting :exc:`asyncio.CancelledError` will interrupt an ``await``, but it will not bubble out of the containing ``async with`` statement."
msgstr "اولین باری که هر وظیفهیمتعلق به گروه با استثنایی غیر از :exc:`asyncio.CancelledError` شکست بخورد، وظایف باقی‌مانده در گروه لغو می‌شوند. پس از آن، دیگر نمی‌توان وظیفه دیگری به گروه افزود. در این نقطه، اگر بدنه دستور ``async with`` هنوز فعال باشد (یعنی :meth:`~object.__aexit__` هنوز فراخوانی نشده باشد)، وظیفهی که مستقیماً دربرگیرنده دستور ``async with`` است نیز لغو می‌شود. :exc:`asyncio.CancelledError` حاصل، یک ``await`` را قطع می‌کند، اما از دستور ``async with`` دربرگیرنده بیرون نخواهد زد."

msgid "Once all tasks have finished, if any tasks have failed with an exception other than :exc:`asyncio.CancelledError`, those exceptions are combined in an :exc:`ExceptionGroup` or :exc:`BaseExceptionGroup` (as appropriate; see their documentation) which is then raised."
msgstr "پس از پایان یافتن همه وظایف، اگر هر یک از وظایف با استثنایی غیر از :exc:`asyncio.CancelledError` شکست خورده باشند، آن استثناها در یک :exc:`ExceptionGroup` یا :exc:`BaseExceptionGroup` (بسته به مورد؛ مستندات آن‌ها را ببینید) ترکیب می‌شوند که سپس پرتاب می‌شود."

msgid "Two base exceptions are treated specially: If any task fails with :exc:`KeyboardInterrupt` or :exc:`SystemExit`, the task group still cancels the remaining tasks and waits for them, but then the initial :exc:`KeyboardInterrupt` or :exc:`SystemExit` is re-raised instead of :exc:`ExceptionGroup` or :exc:`BaseExceptionGroup`."
msgstr "دو استثنای پایه به‌صورت ویژه مدیریت می‌شوند: اگر هر وظیفه‌ای  با :exc:`KeyboardInterrupt` یا :exc:`SystemExit` شکست بخورد، گروه وظیفه (task group) همچنان وظایف باقی‌مانده را لغو می‌کند و منتظر آن‌ها می‌ماند، اما سپس :exc:`KeyboardInterrupt` یا :exc:`SystemExit` اولیه به‌جای :exc:`ExceptionGroup` یا :exc:`BaseExceptionGroup` دوباره پرتاب می‌شود."

msgid "If the body of the ``async with`` statement exits with an exception (so :meth:`~object.__aexit__` is called with an exception set), this is treated the same as if one of the tasks failed: the remaining tasks are cancelled and then waited for, and non-cancellation exceptions are grouped into an exception group and raised. The exception passed into :meth:`~object.__aexit__`, unless it is :exc:`asyncio.CancelledError`, is also included in the exception group. The same special case is made for :exc:`KeyboardInterrupt` and :exc:`SystemExit` as in the previous paragraph."
msgstr "اگر بدنه‌ی دستور ``async with`` با یک استثنا خارج شود (بنابراین :meth:`~object.__aexit__` در حالی فراخوانی می‌شود که یک استثنا تنظیم شده است)، با این مورد مانند حالتی رفتار می‌شود که یکی از وظایف شکست خورده باشد: وظایف باقی‌مانده لغو می‌شوند و سپس برای آن‌ها انتظار می‌رود، و استثناهای غیر از لغو در یک گروه استثنا دسته‌بندی و پرتاب می‌شوند. استثنایی که به :meth:`~object.__aexit__` داده می‌شود، مگر آنکه :exc:`asyncio.CancelledError` باشد، نیز در گروه استثنا گنجانده می‌شود. همان حالت خاص پاراگراف قبلی برای :exc:`KeyboardInterrupt` و :exc:`SystemExit` نیز اعمال می‌شود."

msgid "Task groups are careful not to mix up the internal cancellation used to \"wake up\" their :meth:`~object.__aexit__` with cancellation requests for the task in which they are running made by other parties. In particular, when one task group is syntactically nested in another, and both experience an exception in one of their child tasks simultaneously, the inner task group will process its exceptions, and then the outer task group will receive another cancellation and process its own exceptions."
msgstr "گروه‌های وظیفه مراقب هستند که لغو داخلیِ استفاده‌شده برای «بیدار کردن» :meth:`~object.__aexit__` خود را با درخواست‌های لغو برای وظیفهی که در آن در حال اجرا هستند و از سوی طرف‌های دیگر مطرح شده‌اند، اشتباه نگیرند. به‌ویژه، هنگامی که یک گروه وظیفه از نظر نحوی در گروه دیگری تودرتو شده باشد و هر دو همزمان در یکی از وظایف فرزند خود با استثنا مواجه شوند، گروه وظیفه داخلی استثناهای خود را پردازش می‌کند و سپس گروه وظیفه خارجی لغو دیگری را دریافت می‌کند و استثناهای خود را پردازش می‌کند."

msgid "In the case where a task group is cancelled externally and also must raise an :exc:`ExceptionGroup`, it will call the parent task's :meth:`~asyncio.Task.cancel` method. This ensures that a :exc:`asyncio.CancelledError` will be raised at the next :keyword:`await`, so the cancellation is not lost."
msgstr "در حالتی که یک گروه وظیفه از بیرون لغو می‌شود و همچنین باید یک :exc:`ExceptionGroup` را پرتاب کند، متد :meth:`~asyncio.Task.cancel` مربوط به وظیفه‌ی والد (parent task) را فراخوانی می‌کند. این کار تضمین می‌کند که یک :exc:`asyncio.CancelledError` در :keyword:`await` بعدی پرتاب می‌شود، بنابراین لغو از دست نمی‌رود."

msgid "Task groups preserve the cancellation count reported by :meth:`asyncio.Task.cancelling`."
msgstr "گروه‌های Task تعداد لغو گزارش‌شده توسط :meth:`asyncio.Task.cancelling` را حفظ می‌کنند."

msgid "Improved handling of simultaneous internal and external cancellations and correct preservation of cancellation counts."
msgstr "مدیریت بهتر لغوهای همزمان داخلی و خارجی و حفظ صحیح تعداد لغوها."

msgid "Terminating a task group"
msgstr "پایان دادن به گروه وظیفه"

msgid "While terminating a task group is not natively supported by the standard library, termination can be achieved by adding an exception-raising task to the task group and ignoring the raised exception:"
msgstr "اگرچه پایان دادن به یک گروه وظیفه به‌صورت بومی توسط کتابخانه استاندارد پشتیبانی نمی‌شود، می‌توان با افزودن وظیفه‌ای که استثنا پرتاب می‌کند به گروه وظیفه و نادیده گرفتن استثنای پرتاب‌شده، آن را پایان داد:"

msgid ""
"import asyncio\n"
"from asyncio import TaskGroup\n"
"\n"
"class TerminateTaskGroup(Exception):\n"
"    \"\"\"Exception raised to terminate a task group.\"\"\"\n"
"\n"
"async def force_terminate_task_group():\n"
"    \"\"\"Used to force termination of a task group.\"\"\"\n"
"    raise TerminateTaskGroup()\n"
"\n"
"async def job(task_id, sleep_time):\n"
"    print(f'Task {task_id}: start')\n"
"    await asyncio.sleep(sleep_time)\n"
"    print(f'Task {task_id}: done')\n"
"\n"
"async def main():\n"
"    try:\n"
"        async with TaskGroup() as group:\n"
"            # spawn some tasks\n"
"            group.create_task(job(1, 0.5))\n"
"            group.create_task(job(2, 1.5))\n"
"            # sleep for 1 second\n"
"            await asyncio.sleep(1)\n"
"            # add an exception-raising task to force the group to terminate\n"
"            group.create_task(force_terminate_task_group())\n"
"    except* TerminateTaskGroup:\n"
"        pass\n"
"\n"
"asyncio.run(main())"
msgstr ""
"import asyncio\n"
"from asyncio import TaskGroup\n"
"\n"
"class TerminateTaskGroup(Exception):\n"
"    \"\"\"Exception raised to terminate a task group.\"\"\"\n"
"\n"
"async def force_terminate_task_group():\n"
"    \"\"\"Used to force termination of a task group.\"\"\"\n"
"    raise TerminateTaskGroup()\n"
"\n"
"async def job(task_id, sleep_time):\n"
"    print(f'Task {task_id}: start')\n"
"    await asyncio.sleep(sleep_time)\n"
"    print(f'Task {task_id}: done')\n"
"\n"
"async def main():\n"
"    try:\n"
"        async with TaskGroup() as group:\n"
"            # spawn some tasks\n"
"            group.create_task(job(1, 0.5))\n"
"            group.create_task(job(2, 1.5))\n"
"            # sleep for 1 second\n"
"            await asyncio.sleep(1)\n"
"            # add an exception-raising task to force the group to terminate\n"
"            group.create_task(force_terminate_task_group())\n"
"    except* TerminateTaskGroup:\n"
"        pass\n"
"\n"
"asyncio.run(main())"

msgid "Expected output:"
msgstr "خروجی مورد انتظار:"

msgid ""
"Task 1: start\n"
"Task 2: start\n"
"Task 1: done"
msgstr ""
"Task 1: start\n"
"Task 2: start\n"
"Task 1: done"

msgid "Sleeping"
msgstr "توقف"

msgid "Block for *delay* seconds."
msgstr "به مدت *delay* ثانیه مسدود می‌شود."

msgid "If *result* is provided, it is returned to the caller when the coroutine completes."
msgstr "اگر *result* ارائه شده باشد، پس از تکمیل هم‌روال، به فراخواننده بازگردانده می‌شود."

msgid "``sleep()`` always suspends the current task, allowing other tasks to run."
msgstr "``sleep()`` همیشه وظیفهجاری را معلق می‌کند و به سایر وظایف اجازه اجرا می‌دهد."

msgid "Setting the delay to 0 provides an optimized path to allow other tasks to run. This can be used by long-running functions to avoid blocking the event loop for the full duration of the function call."
msgstr "تنظیم تأخیر روی ۰ مسیر بهینه‌ای را فراهم می‌کند که به سایر وظایف اجازه اجرا می‌دهد. توابع طولانی‌مدت می‌توانند از این امکان برای جلوگیری از مسدود کردن حلقه رویداد در تمام مدت فراخوانی تابع استفاده کنند."

msgid "Example of coroutine displaying the current date every second for 5 seconds::"
msgstr "مثالی از یک هم‌روال که تاریخ جاری را هر ثانیه به مدت ۵ ثانیه نمایش می‌دهد::"

msgid ""
"import asyncio\n"
"import datetime as dt\n"
"\n"
"async def display_date():\n"
"    loop = asyncio.get_running_loop()\n"
"    end_time = loop.time() + 5.0\n"
"    while True:\n"
"        print(dt.datetime.now())\n"
"        if (loop.time() + 1.0) >= end_time:\n"
"            break\n"
"        await asyncio.sleep(1)\n"
"\n"
"asyncio.run(display_date())"
msgstr ""
"import asyncio\n"
"import datetime as dt\n"
"\n"
"async def display_date():\n"
"    loop = asyncio.get_running_loop()\n"
"    end_time = loop.time() + 5.0\n"
"    while True:\n"
"        print(dt.datetime.now())\n"
"        if (loop.time() + 1.0) >= end_time:\n"
"            break\n"
"        await asyncio.sleep(1)\n"
"\n"
"asyncio.run(display_date())"

msgid "Removed the *loop* parameter."
msgstr "پارامتر *loop* حذف شد."

msgid "Raises :exc:`ValueError` if *delay* is :data:`~math.nan`."
msgstr "اگر *delay* برابر با :data:`~math.nan` باشد، :exc:`ValueError` پرتاب می‌شود."

msgid "Running tasks concurrently"
msgstr "اجرای همزمان وظایف"

msgid "Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws* sequence *concurrently*."
msgstr ":ref:`اشیاء awaitable <asyncio-awaitables>` را در دنباله‌ی *aws* به‌صورت *همزمان* اجرا کنید."

msgid "If any awaitable in *aws* is a coroutine, it is automatically scheduled as a Task."
msgstr "اگر هر awaitable در *aws* یک هم‌روال باشد، به‌طور خودکار به‌عنوان یک Task زمان‌بندی می‌شود."

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ها با موفقیت کامل شوند، نتیجه یک فهرست تجمیعی از مقادیر بازگشتی است. ترتیب مقادیر نتیجه با ترتیب awaitableها در *aws* مطابقت دارد."

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 می‌کند، منتشر می‌شود. سایر اشیاء قابل انتظار (awaitable) در دنباله‌ی *aws* **لغو نخواهند شد** و به اجرا ادامه خواهند داد."

msgid "If *return_exceptions* is ``True``, exceptions are treated the same as successful results, and aggregated in the result list."
msgstr "اگر *return_exceptions* برابر ``True`` باشد، استثناها همانند نتایج موفق در نظر گرفته می‌شوند و در فهرست نتایج جمع‌آوری می‌شوند."

msgid "If ``gather()`` is *cancelled*, all submitted awaitables (that have not completed yet) are also *cancelled*."
msgstr "اگر ``gather()`` *لغو شود*، تمام awaitableهای ارسال‌شده (که هنوز کامل نشده‌اند) نیز *لغو می‌شوند*."

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 "اگر هر Task یا Future از دنباله‌ی *aws* *لغوشده* باشد، با آن به‌گونه‌ای رفتار می‌شود که گویی :exc:`CancelledError` را پرتاب کرده است — در این حالت، فراخوانی ``gather()`` لغو **نمی‌شود**. این برای جلوگیری از این است که لغو یک Task/Future ارسال‌شده، باعث لغو سایر Taskها/Futureها شود."

msgid "A new alternative to create and run tasks concurrently and wait for their completion is :class:`asyncio.TaskGroup`. *TaskGroup* provides stronger safety guarantees than *gather* for scheduling a nesting of subtasks: if a task (or a subtask, a task scheduled by a task) raises an exception, *TaskGroup* will, while *gather* will not, cancel the remaining scheduled tasks."
msgstr "یک جایگزین جدید برای ایجاد و اجرای همزمان وظیفه‌ها و انتظار برای تکمیل آن‌ها، :class:`asyncio.TaskGroup` است. *TaskGroup* برای زمان‌بندی زیروظیفه‌های تودرتو، نسبت به *gather* تضمین‌های ایمنی قوی‌تری فراهم می‌کند: اگر یک وظیفه (یا یک زیروظیفه، یعنی وظیفه‌ای که توسط یک وظیفه زمان‌بندی شده است) استثنایی را پرتاب کند، *TaskGroup* وظیفه‌های زمان‌بندی‌شده‌ی باقی‌مانده را لغو می‌کند، در حالی که *gather* این کار را نمی‌کند."

msgid ""
"import asyncio\n"
"\n"
"async def factorial(name, number):\n"
"    f = 1\n"
"    for i in range(2, number + 1):\n"
"        print(f\"Task {name}: Compute factorial({number}), currently i={i}...\")\n"
"        await asyncio.sleep(1)\n"
"        f *= i\n"
"    print(f\"Task {name}: factorial({number}) = {f}\")\n"
"    return f\n"
"\n"
"async def main():\n"
"    # Schedule three calls *concurrently*:\n"
"    L = await asyncio.gather(\n"
"        factorial(\"A\", 2),\n"
"        factorial(\"B\", 3),\n"
"        factorial(\"C\", 4),\n"
"    )\n"
"    print(L)\n"
"\n"
"asyncio.run(main())\n"
"\n"
"# Expected output:\n"
"#\n"
"#     Task A: Compute factorial(2), currently i=2...\n"
"#     Task B: Compute factorial(3), currently i=2...\n"
"#     Task C: Compute factorial(4), currently i=2...\n"
"#     Task A: factorial(2) = 2\n"
"#     Task B: Compute factorial(3), currently i=3...\n"
"#     Task C: Compute factorial(4), currently i=3...\n"
"#     Task B: factorial(3) = 6\n"
"#     Task C: Compute factorial(4), currently i=4...\n"
"#     Task C: factorial(4) = 24\n"
"#     [2, 6, 24]"
msgstr ""
"import asyncio\n"
"\n"
"async def factorial(name, number):\n"
"    f = 1\n"
"    for i in range(2, number + 1):\n"
"        print(f\"Task {name}: Compute factorial({number}), currently i={i}...\")\n"
"        await asyncio.sleep(1)\n"
"        f *= i\n"
"    print(f\"Task {name}: factorial({number}) = {f}\")\n"
"    return f\n"
"\n"
"async def main():\n"
"    # Schedule three calls *concurrently*:\n"
"    L = await asyncio.gather(\n"
"        factorial(\"A\", 2),\n"
"        factorial(\"B\", 3),\n"
"        factorial(\"C\", 4),\n"
"    )\n"
"    print(L)\n"
"\n"
"asyncio.run(main())\n"
"\n"
"# Expected output:\n"
"#\n"
"#     Task A: Compute factorial(2), currently i=2...\n"
"#     Task B: Compute factorial(3), currently i=2...\n"
"#     Task C: Compute factorial(4), currently i=2...\n"
"#     Task A: factorial(2) = 2\n"
"#     Task B: Compute factorial(3), currently i=3...\n"
"#     Task C: Compute factorial(4), currently i=3...\n"
"#     Task B: factorial(3) = 6\n"
"#     Task C: Compute factorial(4), currently i=4...\n"
"#     Task C: factorial(4) = 24\n"
"#     [2, 6, 24]"

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* نادرست باشد، لغو gather() پس از آن‌که به‌عنوان انجام‌شده علامت‌گذاری شده باشد، هیچ‌کدام از موارد قابل await (awaitable) ارسال‌شده را لغو نمی‌کند. برای مثال، gather می‌تواند پس از انتشار یک استثنا به فراخواننده، به‌عنوان انجام‌شده علامت‌گذاری شود؛ بنابراین، فراخوانی ``gather.cancel()`` پس از گرفتن استثنایی از gather (که توسط یکی از موارد قابل await پرتاب‌شده است)، هیچ مورد قابل await دیگری را لغو نمی‌کند."

msgid "If the *gather* itself is cancelled, the cancellation is propagated regardless of *return_exceptions*."
msgstr "اگر خود *gather* لغو شود، لغو صرف‌نظر از *return_exceptions* انتشار می‌یابد."

msgid "Deprecation warning is emitted if no positional arguments are provided or not all positional arguments are Future-like objects and there is no running event loop."
msgstr "در صورتی که هیچ آرگومان جایگاهی ارائه نشده باشد یا همه‌ی آرگومان‌های جایگاهی اشیای Future-مانند نباشند و هیچ حلقه‌ی رویدادی در حال اجرا وجود نداشته باشد، هشدار از رده خارج شدن نشان داده می‌شود."

msgid "Eager task factory"
msgstr "کارخانه‌ی وظیفه حریصانه (Eager task factory)"

msgid "A task factory for eager task execution."
msgstr "یک کارخانه‌ی وظیفهبرای اجرای فوری وظیفه."

msgid "When using this factory (via :meth:`loop.set_task_factory(asyncio.eager_task_factory) <loop.set_task_factory>`), coroutines begin execution synchronously during :class:`Task` construction. Tasks are only scheduled on the event loop if they block. This can be a performance improvement as the overhead of loop scheduling is avoided for coroutines that complete synchronously."
msgstr "هنگام استفاده از این کارخانه (از طریق :meth:`loop.set_task_factory(asyncio.eager_task_factory) <loop.set_task_factory>`)، هم‌روال‌ها اجرای خود را به‌صورت همگام در حین ساخت :class:`Task` آغاز می‌کنند. وظایفتنها در صورتی که مسدود شوند، در حلقه رویداد زمان‌بندی می‌شوند. این می‌تواند بهبودی در عملکرد باشد، زیرا از سربار زمان‌بندی حلقه برای هم‌روال‌هایی که به‌صورت همگام کامل می‌شوند جلوگیری می‌شود."

msgid "A common example where this is beneficial is coroutines which employ caching or memoization to avoid actual I/O when possible."
msgstr "یک مثال رایج که در آن این موضوع مفید است، هم‌روال‌هایی هستند که از نهانگاه‌سازی یا به‌خاطرسپاری (memoization) برای پرهیز از ورودی/خروجی واقعی در صورت امکان استفاده می‌کنند."

msgid "Immediate execution of the coroutine is a semantic change. If the coroutine returns or raises, the task is never scheduled to the event loop. If the coroutine execution blocks, the task is scheduled to the event loop. This change may introduce behavior changes to existing applications. For example, the application's task execution order is likely to change."
msgstr "اجرای فوری هم‌روال یک تغییر معنایی است. اگر هم‌روال مقداری برگرداند یا استثنایی پرتاب کند، وظیفه هرگز در حلقه رویداد زمان‌بندی نمی‌شود. اگر اجرای هم‌روال مسدود شود، وظیفه در حلقه رویداد زمان‌بندی می‌شود. این تغییر ممکن است تغییراتی در رفتار برنامه‌های موجود ایجاد کند. برای مثال، ترتیب اجرای وظایف برنامه احتمالاً تغییر خواهد کرد."

msgid "Create an eager task factory, similar to :func:`eager_task_factory`, using the provided *custom_task_constructor* when creating a new task instead of the default :class:`Task`."
msgstr "یک کارخانه وظیفه فوری ایجاد کنید، مشابه :func:`eager_task_factory`، که هنگام ایجاد یک وظیفه جدید، به‌جای :class:`Task` پیش‌فرض، از *custom_task_constructor* ارائه‌شده استفاده می‌کند."

msgid "*custom_task_constructor* must be a *callable* with the signature matching the signature of :class:`Task.__init__ <Task>`. The callable must return a :class:`asyncio.Task`-compatible object."
msgstr "*custom_task_constructor* باید یک *فراخوانی‌پذیر* با امضایی مطابق با امضای :class:`Task.__init__ <Task>` باشد. این فراخوانی‌پذیر باید یک شیء سازگار با :class:`asyncio.Task` بازگشت دهد."

msgid "This function returns a *callable* intended to be used as a task factory of an event loop via :meth:`loop.set_task_factory(factory) <loop.set_task_factory>`)."
msgstr "این تابع یک شیء *فراخوانی‌پذیر* را برمی‌گرداند که برای استفاده به‌عنوان کارخانه‌ی وظیفه یک حلقه‌ی رویداد از طریق :meth:`loop.set_task_factory(factory) <loop.set_task_factory>` در نظر گرفته شده است."

msgid "Shielding from cancellation"
msgstr "محافظت در برابر لغو"

msgid "Protect an :ref:`awaitable object <asyncio-awaitables>` from being :meth:`cancelled <Task.cancel>`."
msgstr "از یک :ref:`شیء awaitable <asyncio-awaitables>` در برابر :meth:`لغو شدن <Task.cancel>` محافظت کنید."

msgid "If *aw* is a coroutine it is automatically scheduled as a Task."
msgstr "اگر *aw* یک هم‌روال باشد، به‌طور خودکار به‌عنوان یک Task زمان‌بندی می‌شود."

msgid "The statement::"
msgstr "دستور::"

msgid ""
"task = asyncio.create_task(something())\n"
"res = await shield(task)"
msgstr ""
"task = asyncio.create_task(something())\n"
"res = await shield(task)"

msgid "is equivalent to::"
msgstr "معادل است با::"

msgid "res = await something()"
msgstr "res = await something()"

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 "*به جز* اینکه اگر هم‌روال حاوی آن لغو شود، Task در حال اجرا در ``something()`` لغو نمی‌شود. از دید ``something()``، لغو رخ نداده است. اگرچه فراخواننده‌ی آن همچنان لغو می‌شود، بنابراین عبارت \"await\" همچنان یک :exc:`CancelledError` را پرتاب می‌کند."

msgid "If ``something()`` is cancelled by other means (i.e. from within itself) that would also cancel ``shield()``."
msgstr "اگر ``something()`` به روش‌های دیگر لغو شود (یعنی از درون خودش)، این موضوع ``shield()`` را نیز لغو می‌کند."

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 "اگر مطلوب باشد که لغو (cancellation) به‌طور کامل نادیده گرفته شود (توصیه نمی‌شود)، باید تابع ``shield()`` را با یک بند try/except ترکیب کرد، به‌صورت زیر::"

msgid ""
"task = asyncio.create_task(something())\n"
"try:\n"
"    res = await shield(task)\n"
"except CancelledError:\n"
"    res = None"
msgstr ""
"task = asyncio.create_task(something())\n"
"try:\n"
"    res = await shield(task)\n"
"except CancelledError:\n"
"    res = None"

msgid "Save a reference to tasks passed to this function, to avoid a task disappearing mid-execution. The event loop only keeps weak references to tasks. A task that isn't referenced elsewhere may get garbage collected at any time, even before it's done."
msgstr "برای جلوگیری از ناپدید شدن یک وظیفه در میانه‌ی اجرا، ارجاعی به وظایف داده‌شده به این تابع ذخیره کنید. حلقه‌ی رویداد فقط ارجاع‌های ضعیف به وظایف را نگه می‌دارد. وظیفهی که در جای دیگری به آن ارجاع داده نشده است، ممکن است در هر زمانی، حتی پیش از آنکه به پایان برسد، زباله‌روبی شود."

msgid "Deprecation warning is emitted if *aw* is not Future-like object and there is no running event loop."
msgstr "اگر *aw* یک شیء شبیه Future نباشد و حلقه رویدادی در حال اجرا وجود نداشته باشد، هشدار از رده خارج شدن نشان داده می‌شود."

msgid "Timeouts"
msgstr "مهلت‌های زمانی"

msgid "Return an :ref:`asynchronous context manager <async-context-managers>` that can be used to limit the amount of time spent waiting on something."
msgstr "یک :ref:`مدیر زمینه ناهمگام <async-context-managers>` برمی‌گرداند که می‌توان از آن برای محدود کردن مدت زمانی که صرف انتظار برای چیزی می‌شود استفاده کرد."

msgid "*delay* can either be ``None``, or a float/int number of seconds to wait. If *delay* is ``None``, no time limit will be applied; this can be useful if the delay is unknown when the context manager is created."
msgstr "*delay* می‌تواند ``None`` یا عددی از نوع float/int برای تعداد ثانیه‌های انتظار باشد. اگر *delay* برابر ``None`` باشد، هیچ محدودیت زمانی اعمال نخواهد شد؛ این موضوع می‌تواند زمانی مفید باشد که تأخیر در هنگام ایجاد مدیر زمینه نامشخص باشد."

msgid "In either case, the context manager can be rescheduled after creation using :meth:`Timeout.reschedule`."
msgstr "در هر صورت، می‌توان مدیر زمینه را پس از ایجاد، با استفاده از :meth:`Timeout.reschedule` دوباره زمان‌بندی کرد."

msgid ""
"async def main():\n"
"    async with asyncio.timeout(10):\n"
"        await long_running_task()"
msgstr ""
"async def main():\n"
"    async with asyncio.timeout(10):\n"
"        await long_running_task()"

msgid "If ``long_running_task`` takes more than 10 seconds to complete, the context manager will cancel the current task and handle the resulting :exc:`asyncio.CancelledError` internally, transforming it into a :exc:`TimeoutError` which can be caught and handled."
msgstr "اگر تکمیل ``long_running_task`` بیش از ۱۰ ثانیه طول بکشد، مدیر زمینه، وظیفه جاری را لغو می‌کند و :exc:`asyncio.CancelledError` حاصل را به‌صورت داخلی مدیریت می‌کند و آن را به :exc:`TimeoutError` تبدیل می‌کند که می‌توان آن را گرفت و مدیریت کرد."

msgid "The :func:`asyncio.timeout` context manager is what transforms the :exc:`asyncio.CancelledError` into a :exc:`TimeoutError`, which means the :exc:`TimeoutError` can only be caught *outside* of the context manager."
msgstr "مدیر زمینه‌ی :func:`asyncio.timeout` همان چیزی است که :exc:`asyncio.CancelledError` را به :exc:`TimeoutError` تبدیل می‌کند، به این معنا که :exc:`TimeoutError` فقط در *خارج* از مدیر زمینه قابل گرفتن است."

msgid "Example of catching :exc:`TimeoutError`::"
msgstr "نمونه‌ای از گرفتن :exc:`TimeoutError`::"

msgid ""
"async def main():\n"
"    try:\n"
"        async with asyncio.timeout(10):\n"
"            await long_running_task()\n"
"    except TimeoutError:\n"
"        print(\"The long operation timed out, but we've handled it.\")\n"
"\n"
"    print(\"This statement will run regardless.\")"
msgstr ""
"async def main():\n"
"    try:\n"
"        async with asyncio.timeout(10):\n"
"            await long_running_task()\n"
"    except TimeoutError:\n"
"        print(\"The long operation timed out, but we've handled it.\")\n"
"\n"
"    print(\"This statement will run regardless.\")"

msgid "The context manager produced by :func:`asyncio.timeout` can be rescheduled to a different deadline and inspected."
msgstr "مدیر زمینه تولیدشده توسط :func:`asyncio.timeout` می‌تواند برای مهلتی دیگر دوباره زمان‌بندی و بازرسی شود."

msgid "An :ref:`asynchronous context manager <async-context-managers>` for cancelling overdue coroutines."
msgstr "یک :ref:`مدیر زمینه ناهمگام <async-context-managers>` برای لغو هم‌روال‌های منقضی‌شده."

msgid "Prefer using :func:`asyncio.timeout` or :func:`asyncio.timeout_at` rather than instantiating :class:`!Timeout` directly."
msgstr "ترجیحاً به‌جای نمونه‌سازی مستقیم :class:`!Timeout`، از :func:`asyncio.timeout` یا :func:`asyncio.timeout_at` استفاده کنید."

msgid "``when`` should be an absolute time at which the context should time out, as measured by the event loop's clock:"
msgstr "``when`` باید یک زمان مطلق باشد که در آن زمینه باید منقضی شود، همان‌طور که با ساعت حلقه رویداد اندازه‌گیری می‌شود:"

msgid "If ``when`` is ``None``, the timeout will never trigger."
msgstr "اگر ``when`` برابر ``None`` باشد، مهلت زمانی هرگز فعال نخواهد شد."

msgid "If ``when < loop.time()``, the timeout will trigger on the next iteration of the event loop."
msgstr "اگر ``when < loop.time()`` باشد، مهلت زمانی در تکرار بعدی حلقه رویداد فعال خواهد شد."

msgid "Return the current deadline, or ``None`` if the current deadline is not set."
msgstr "مهلت فعلی را برمی‌گرداند، یا اگر مهلت فعلی تنظیم‌نشده باشد ``None`` را برمی‌گرداند."

msgid "Reschedule the timeout."
msgstr "مهلت را دوباره زمان‌بندی کنید."

msgid "Return whether the context manager has exceeded its deadline (expired)."
msgstr "برمی‌گرداند که آیا مدیر زمینه از مهلت خود گذشته است (منقضی‌شده است)."

msgid ""
"async def main():\n"
"    try:\n"
"        # We do not know the timeout when starting, so we pass ``None``.\n"
"        async with asyncio.timeout(None) as cm:\n"
"            # We know the timeout now, so we reschedule it.\n"
"            new_deadline = get_running_loop().time() + 10\n"
"            cm.reschedule(new_deadline)\n"
"\n"
"            await long_running_task()\n"
"    except TimeoutError:\n"
"        pass\n"
"\n"
"    if cm.expired():\n"
"        print(\"Looks like we haven't finished on time.\")"
msgstr ""
"async def main():\n"
"    try:\n"
"        # We do not know the timeout when starting, so we pass ``None``.\n"
"        async with asyncio.timeout(None) as cm:\n"
"            # We know the timeout now, so we reschedule it.\n"
"            new_deadline = get_running_loop().time() + 10\n"
"            cm.reschedule(new_deadline)\n"
"\n"
"            await long_running_task()\n"
"    except TimeoutError:\n"
"        pass\n"
"\n"
"    if cm.expired():\n"
"        print(\"Looks like we haven't finished on time.\")"

msgid "Timeout context managers can be safely nested."
msgstr "می‌توان مدیران زمینه‌ی مهلت زمانی را با اطمینان تودرتو کرد."

msgid "Similar to :func:`asyncio.timeout`, except *when* is the absolute time to stop waiting, or ``None``."
msgstr "مشابه :func:`asyncio.timeout`، با این تفاوت که *when* زمان مطلق برای توقف انتظار است، یا ``None``."

msgid ""
"async def main():\n"
"    loop = get_running_loop()\n"
"    deadline = loop.time() + 20\n"
"    try:\n"
"        async with asyncio.timeout_at(deadline):\n"
"            await long_running_task()\n"
"    except TimeoutError:\n"
"        print(\"The long operation timed out, but we've handled it.\")\n"
"\n"
"    print(\"This statement will run regardless.\")"
msgstr ""
"async def main():\n"
"    loop = get_running_loop()\n"
"    deadline = loop.time() + 20\n"
"    try:\n"
"        async with asyncio.timeout_at(deadline):\n"
"            await long_running_task()\n"
"    except TimeoutError:\n"
"        print(\"The long operation timed out, but we've handled it.\")\n"
"\n"
"    print(\"This statement will run regardless.\")"

msgid "Wait for the *aw* :ref:`awaitable <asyncio-awaitables>` to complete with a timeout."
msgstr "منتظر بمانید تا *aw* :ref:`awaitable <asyncio-awaitables>` با یک مهلت زمانی کامل شود."

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`` یا یک عدد float یا int به‌عنوان تعداد ثانیه‌های انتظار باشد. اگر *timeout* برابر ``None`` باشد، تا زمانی که future تکمیل شود، مسدود می‌شود."

msgid "If a timeout occurs, it cancels *aw* and raises :exc:`TimeoutError`."
msgstr "اگر مهلت زمانی رخ دهد، *aw* را لغو می‌کند و :exc:`TimeoutError` را پرتاب می‌کند."

msgid "To prevent *aw* from being cancelled, wrap it in :func:`shield`."
msgstr "برای جلوگیری از لغو شدن *aw*، آن را در :func:`shield` پوشش دهید."

msgid "The function will wait until the future is actually cancelled, so the total wait time may exceed the *timeout*. If an exception happens during cancellation, it is propagated."
msgstr "این تابع تا زمانی که فیوچر (future) به‌طور واقعی لغو شود، صبر می‌کند، بنابراین کل زمان انتظار ممکن است از *timeout* فراتر رود. اگر در حین لغو استثنایی رخ دهد، آن استثنا انتشار می‌یابد."

msgid "If the wait is cancelled, the future *aw* is also cancelled."
msgstr "اگر انتظار لغو شود، آینده *aw* نیز لغو می‌شود."

msgid ""
"async def eternity():\n"
"    # Sleep for one hour\n"
"    await asyncio.sleep(3600)\n"
"    print('yay!')\n"
"\n"
"async def main():\n"
"    # Wait for at most 1 second\n"
"    try:\n"
"        await asyncio.wait_for(eternity(), timeout=1.0)\n"
"    except TimeoutError:\n"
"        print('timeout!')\n"
"\n"
"asyncio.run(main())\n"
"\n"
"# Expected output:\n"
"#\n"
"#     timeout!"
msgstr ""
"async def eternity():\n"
"    # Sleep for one hour\n"
"    await asyncio.sleep(3600)\n"
"    print('yay!')\n"
"\n"
"async def main():\n"
"    # Wait for at most 1 second\n"
"    try:\n"
"        await asyncio.wait_for(eternity(), timeout=1.0)\n"
"    except TimeoutError:\n"
"        print('timeout!')\n"
"\n"
"asyncio.run(main())\n"
"\n"
"# Expected output:\n"
"#\n"
"#     timeout!"

msgid "When *aw* is cancelled due to a timeout, ``wait_for`` waits for *aw* to be cancelled.  Previously, it raised :exc:`TimeoutError` immediately."
msgstr "هنگامی که *aw* به دلیل مهلت زمانی لغو می‌شود، ``wait_for`` منتظر می‌ماند تا *aw* لغو شود. پیش از این، بلافاصله :exc:`TimeoutError` را پرتاب می‌کرد."

msgid "Raises :exc:`TimeoutError` instead of :exc:`asyncio.TimeoutError`."
msgstr ":exc:`TimeoutError` را به‌جای :exc:`asyncio.TimeoutError` پرتاب می‌کند."

msgid "Implemented using :func:`asyncio.timeout`, a coroutine passed as *aw* is no longer wrapped in a :class:`Task` when *timeout* is positive."
msgstr "با استفاده از :func:`asyncio.timeout` پیاده‌سازی شده، یک هم‌روال که به عنوان *aw* پاس داده شده است، وقتی *timeout* مثبت باشد، دیگر در یک :class:`Task` پوشانده نمی‌شود."

msgid "Waiting primitives"
msgstr "اولیه‌های انتظار"

msgid "Run :class:`~asyncio.Future` and :class:`~asyncio.Task` instances in the *aws* iterable concurrently and block until the condition specified by *return_when*."
msgstr "نمونه‌های :class:`~asyncio.Future` و :class:`~asyncio.Task` موجود در پیمایش‌پذیر *aws* را به‌طور همزمان اجرا می‌کند و تا برقراری شرط مشخص‌شده توسط *return_when* مسدود می‌شود."

msgid "The *aws* iterable must not be empty."
msgstr "پیمایش‌پذیر *aws* نباید خالی باشد."

msgid "Returns two sets of Tasks/Futures: ``(done, pending)``."
msgstr "دو مجموعه از Tasks/Futures را برمی‌گرداند: ``(done, pending)``."

msgid "Usage::"
msgstr "استفاده::"

msgid "done, pending = await asyncio.wait(aws)"
msgstr "done, pending = await asyncio.wait(aws)"

msgid "*timeout* (a float or int), if specified, can be used to control the maximum number of seconds to wait before returning."
msgstr "*timeout* (یک float یا int)، در صورت مشخص بودن، می‌تواند برای کنترل حداکثر تعداد ثانیه‌های انتظار پیش از بازگشت استفاده شود."

msgid "Note that this function does not raise :exc:`TimeoutError`. Futures or Tasks that aren't done when the timeout occurs are simply returned in the second set."
msgstr "توجه داشته باشید که این تابع :exc:`TimeoutError` را پرتاب نمی‌کند. Futureها یا Taskهایی که هنگام فرا رسیدن مهلت زمانی انجام نشده‌اند، به‌سادگی در مجموعه دوم برگردانده می‌شوند."

msgid "*return_when* indicates when this function should return.  It must be one of the following constants:"
msgstr "*return_when* نشان می‌دهد که این تابع چه زمانی باید بازگشت کند. این مقدار باید یکی از ثابت‌های زیر باشد:"

msgid "Constant"
msgstr "ثابت"

msgid "Description"
msgstr "توضیح"

msgid "The function will return when any future finishes or is cancelled."
msgstr "تابع هنگامی بازگشت خواهد کرد که هر فیوچر به پایان برسد یا لغو شود."

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` خواهد بود."

msgid "The function will return when all futures finish or are cancelled."
msgstr "تابع زمانی بازگشت می‌کند که همه‌ی آینده‌نماها (futures) پایان یابند یا لغو شوند."

msgid "Unlike :func:`~asyncio.wait_for`, ``wait()`` does not cancel the futures when a timeout occurs."
msgstr "برخلاف :func:`~asyncio.wait_for`، ``wait()`` در صورت وقوع مهلت زمانی، آینده‌نماها (futures) را لغو نمی‌کند."

msgid "If ``wait()`` is cancelled, the futures in *aws* are not cancelled and continue to run."
msgstr "اگر ``wait()`` لغو شود، آینده‌نماها (futures) موجود در *aws* لغو نمی‌شوند و به اجرای خود ادامه می‌دهند."

msgid "Passing coroutine objects to ``wait()`` directly is forbidden."
msgstr "ارسال اشیای هم‌روال به ``wait()`` به‌صورت مستقیم ممنوع است."

msgid "Added support for generators yielding tasks."
msgstr "پشتیبانی از تولیدگرهایی که وظایف را yield می‌کنند، افزوده شد."

msgid "Run :ref:`awaitable objects <asyncio-awaitables>` in the *aws* iterable concurrently. The returned object can be iterated to obtain the results of the awaitables as they finish."
msgstr ":ref:`اشیاء awaitable <asyncio-awaitables>` موجود در پیمایش‌پذیر *aws* را به‌صورت همزمان اجرا کنید. می‌توانید شیء برگردانده‌شده را پیمایش کنید تا نتایج اشیاء awaitable را به‌محض اتمام هرکدام از آن‌ها به دست آورید."

msgid "The object returned by ``as_completed()`` can be iterated as an :term:`asynchronous iterator` or a plain :term:`iterator`. When asynchronous iteration is used, the originally-supplied awaitables are yielded if they are tasks or futures. This makes it easy to correlate previously-scheduled tasks with their results. Example::"
msgstr "می‌توان شیء برگردانده‌شده از ``as_completed()`` را به‌عنوان یک :term:`پیمایش‌گر ناهمگام <asynchronous iterator>` یا یک :term:`پیمایش‌گر <iterator>` ساده پیمایش کرد. هنگامی که از پیمایش ناهمگام استفاده می‌شود، awaitableهایی که در ابتدا ارائه شده‌اند، در صورتی که task یا future باشند، بازگشت داده می‌شوند. این کار مرتبط کردن taskهای از پیش زمان‌بندی‌شده با نتایج آن‌ها را آسان می‌کند. مثال::"

msgid ""
"ipv4_connect = create_task(open_connection(\"127.0.0.1\", 80))\n"
"ipv6_connect = create_task(open_connection(\"::1\", 80))\n"
"tasks = [ipv4_connect, ipv6_connect]\n"
"\n"
"async for earliest_connect in as_completed(tasks):\n"
"    # earliest_connect is done. The result can be obtained by\n"
"    # awaiting it or calling earliest_connect.result()\n"
"    reader, writer = await earliest_connect\n"
"\n"
"    if earliest_connect is ipv6_connect:\n"
"        print(\"IPv6 connection established.\")\n"
"    else:\n"
"        print(\"IPv4 connection established.\")"
msgstr ""
"ipv4_connect = create_task(open_connection(\"127.0.0.1\", 80))\n"
"ipv6_connect = create_task(open_connection(\"::1\", 80))\n"
"tasks = [ipv4_connect, ipv6_connect]\n"
"\n"
"async for earliest_connect in as_completed(tasks):\n"
"    # earliest_connect is done. The result can be obtained by\n"
"    # awaiting it or calling earliest_connect.result()\n"
"    reader, writer = await earliest_connect\n"
"\n"
"    if earliest_connect is ipv6_connect:\n"
"        print(\"IPv6 connection established.\")\n"
"    else:\n"
"        print(\"IPv4 connection established.\")"

msgid "During asynchronous iteration, implicitly-created tasks will be yielded for supplied awaitables that aren't tasks or futures."
msgstr "در حین تکرار ناهمگام، برای awaitableهای فراهم‌شده که task یا future نیستند، taskهایی که به‌صورت ضمنی ایجاد شده‌اند yield داده خواهند شد."

msgid "When used as a plain iterator, each iteration yields a new coroutine that returns the result or raises the exception of the next completed awaitable. This pattern is compatible with Python versions older than 3.13::"
msgstr "هنگامی که به‌عنوان یک پیمایش‌گر ساده استفاده شود، هر تکرار یک هم‌روال جدید به دست می‌دهد که نتیجه‌ی awaitable تکمیل‌شده‌ی بعدی را بازمی‌گرداند یا استثنای آن را پرتاب می‌کند. این الگو با نسخه‌های قدیمی‌تر از 3.13 پایتون سازگار است::"

msgid ""
"ipv4_connect = create_task(open_connection(\"127.0.0.1\", 80))\n"
"ipv6_connect = create_task(open_connection(\"::1\", 80))\n"
"tasks = [ipv4_connect, ipv6_connect]\n"
"\n"
"for next_connect in as_completed(tasks):\n"
"    # next_connect is not one of the original task objects. It must be\n"
"    # awaited to obtain the result value or raise the exception of the\n"
"    # awaitable that finishes next.\n"
"    reader, writer = await next_connect"
msgstr ""
"ipv4_connect = create_task(open_connection(\"127.0.0.1\", 80))\n"
"ipv6_connect = create_task(open_connection(\"::1\", 80))\n"
"tasks = [ipv4_connect, ipv6_connect]\n"
"\n"
"for next_connect in as_completed(tasks):\n"
"    # next_connect is not one of the original task objects. It must be\n"
"    # awaited to obtain the result value or raise the exception of the\n"
"    # awaitable that finishes next.\n"
"    reader, writer = await next_connect"

msgid "A :exc:`TimeoutError` is raised if the timeout occurs before all awaitables are done. This is raised by the ``async for`` loop during asynchronous iteration or by the coroutines yielded during plain iteration."
msgstr "اگر مهلت زمانی پیش از آنکه همه‌ی awaitableها انجام شوند منقضی شود، یک :exc:`TimeoutError` پرتاب می‌شود. این استثنا توسط حلقه‌ی ``async for`` در حین تکرار ناهمگام یا توسط هم‌روال‌هایی که در حین تکرار ساده تولید می‌شوند، پرتاب می‌شود."

msgid "``as_completed()`` does not cancel the tasks running the supplied awaitables: if a timeout occurs or the iteration is cancelled, the remaining tasks continue to run."
msgstr "``as_completed()`` وظایف در حال اجرای awaitableهای ارائه‌شده را لغو نمی‌کند: اگر مهلت به پایان برسد یا پیمایش لغو شود، وظایف باقی‌مانده به اجرا ادامه می‌دهند."

msgid "Deprecation warning is emitted if not all awaitable objects in the *aws* iterable are Future-like objects and there is no running event loop."
msgstr "اگر تمام اشیای awaitable در پیمایش‌پذیر *aws* اشیای شبه-Future نباشند و حلقه رویدادی در حال اجرا وجود نداشته باشد، هشدار از رده خارج شدن نشان داده می‌شود."

msgid "The result can now be used as either an :term:`asynchronous iterator` or as a plain :term:`iterator` (previously it was only a plain iterator)."
msgstr "نتیجه اکنون می‌تواند هم به‌عنوان یک :term:`پیمایش‌گر ناهمگام <asynchronous iterator>` و هم به‌عنوان یک :term:`پیمایش‌گر <iterator>` ساده استفاده شود (پیش‌تر فقط یک پیمایش‌گر ساده بود)."

msgid "Running in threads"
msgstr "اجرا در نخ‌ها"

msgid "Asynchronously run function *func* in a separate thread."
msgstr "تابع *func* را به‌صورت ناهمگام در یک نخ جداگانه اجرا می‌کند."

msgid "Any \\*args and \\*\\*kwargs supplied for this function are directly passed to *func*. Also, the current :class:`contextvars.Context` is propagated, allowing context variables from the event loop thread to be accessed in the separate thread."
msgstr "هرگونه \\*args و \\*\\*kwargs که برای این تابع ارائه شود، مستقیماً به *func* ارسال می‌شود. همچنین :class:`contextvars.Context` جاری منتشر می‌شود تا متغیرهای زمینه از نخ حلقه رویداد در نخ جداگانه قابل دسترسی باشند."

msgid "Return a coroutine that can be awaited to get the eventual result of *func*."
msgstr "یک هم‌روال برمی‌گرداند که می‌توان آن را await کرد تا نتیجه نهایی *func* به دست آید."

msgid "This coroutine function is primarily intended to be used for executing IO-bound functions/methods that would otherwise block the event loop if they were run in the main thread. For example::"
msgstr "این تابع هم‌روال عمدتاً برای اجرای توابع/متدهای وابسته به ورودی/خروجی (IO-bound) در نظر گرفته شده است، توابعی که در غیر این صورت، اگر در نخ اصلی اجرا شوند، حلقه رویداد را مسدود می‌کنند. برای مثال::"

msgid ""
"def blocking_io():\n"
"    print(f\"start blocking_io at {time.strftime('%X')}\")\n"
"    # Note that time.sleep() can be replaced with any blocking\n"
"    # IO-bound operation, such as file operations.\n"
"    time.sleep(1)\n"
"    print(f\"blocking_io complete at {time.strftime('%X')}\")\n"
"\n"
"async def main():\n"
"    print(f\"started main at {time.strftime('%X')}\")\n"
"\n"
"    await asyncio.gather(\n"
"        asyncio.to_thread(blocking_io),\n"
"        asyncio.sleep(1))\n"
"\n"
"    print(f\"finished main at {time.strftime('%X')}\")\n"
"\n"
"\n"
"asyncio.run(main())\n"
"\n"
"# Expected output:\n"
"#\n"
"# started main at 19:50:53\n"
"# start blocking_io at 19:50:53\n"
"# blocking_io complete at 19:50:54\n"
"# finished main at 19:50:54"
msgstr ""
"def blocking_io():\n"
"    print(f\"start blocking_io at {time.strftime('%X')}\")\n"
"    # Note that time.sleep() can be replaced with any blocking\n"
"    # IO-bound operation, such as file operations.\n"
"    time.sleep(1)\n"
"    print(f\"blocking_io complete at {time.strftime('%X')}\")\n"
"\n"
"async def main():\n"
"    print(f\"started main at {time.strftime('%X')}\")\n"
"\n"
"    await asyncio.gather(\n"
"        asyncio.to_thread(blocking_io),\n"
"        asyncio.sleep(1))\n"
"\n"
"    print(f\"finished main at {time.strftime('%X')}\")\n"
"\n"
"\n"
"asyncio.run(main())\n"
"\n"
"# Expected output:\n"
"#\n"
"# started main at 19:50:53\n"
"# start blocking_io at 19:50:53\n"
"# blocking_io complete at 19:50:54\n"
"# finished main at 19:50:54"

msgid "Directly calling ``blocking_io()`` in any coroutine would block the event loop for its duration, resulting in an additional 1 second of run time. Instead, by using ``asyncio.to_thread()``, we can run it in a separate thread without blocking the event loop."
msgstr "فراخوانی مستقیم ``blocking_io()`` در هر هم‌روالی، حلقه رویداد را برای مدت آن مسدود می‌کند و باعث افزایش ۱ ثانیه‌ای زمان اجرا می‌شود. در عوض، با استفاده از ``asyncio.to_thread()`` می‌توانیم آن را در یک نخ جداگانه بدون مسدود کردن حلقه رویداد اجرا کنیم."

msgid "Due to the :term:`GIL`, ``asyncio.to_thread()`` can typically only be used to make IO-bound functions non-blocking. However, for extension modules that release the GIL or alternative Python implementations that don't have one, ``asyncio.to_thread()`` can also be used for CPU-bound functions."
msgstr "به دلیل :term:`GIL`، معمولاً فقط می‌توان از ``asyncio.to_thread()`` برای غیرمسدود کردن توابع محدود به ورودی/خروجی (IO-bound) استفاده کرد. با این حال، برای ماژول‌های توسعه‌ای که GIL را آزاد می‌کنند یا پیاده‌سازی‌های جایگزین پایتون که GIL ندارند، می‌توان از ``asyncio.to_thread()`` برای توابع محدود به پردازنده (CPU-bound) نیز استفاده کرد."

msgid "Scheduling from other threads"
msgstr "زمان‌بندی از نخ‌های دیگر"

msgid "Submit a coroutine to the given event loop.  Thread-safe."
msgstr "یک هم‌روال را به حلقه رویداد داده‌شده ارسال کنید. نخ‌ایمن."

msgid "Return a :class:`concurrent.futures.Future` to wait for the result from another OS thread."
msgstr "یک :class:`concurrent.futures.Future` برمی‌گرداند تا بتوان از یک نخ سیستم‌عامل دیگر منتظر نتیجه ماند."

msgid "This function is meant to be called from a different OS thread than the one where the event loop is running.  Example::"
msgstr "این تابع برای فراخوانی از یک نخ سیستم‌عامل متفاوت از نخی که حلقه رویداد در آن اجرا می‌شود، در نظر گرفته شده است. مثال::"

msgid ""
"def in_thread(loop: asyncio.AbstractEventLoop) -> None:\n"
"    # Run some blocking IO\n"
"    pathlib.Path(\"example.txt\").write_text(\"hello world\", encoding=\"utf8\")\n"
"\n"
"    # Create a coroutine\n"
"    coro = asyncio.sleep(1, result=3)\n"
"\n"
"    # Submit the coroutine to a given loop\n"
"    future = asyncio.run_coroutine_threadsafe(coro, loop)\n"
"\n"
"    # Wait for the result with an optional timeout argument\n"
"    assert future.result(timeout=2) == 3\n"
"\n"
"async def amain() -> None:\n"
"    # Get the running loop\n"
"    loop = asyncio.get_running_loop()\n"
"\n"
"    # Run something in a thread\n"
"    await asyncio.to_thread(in_thread, loop)"
msgstr ""
"def in_thread(loop: asyncio.AbstractEventLoop) -> None:\n"
"    # Run some blocking IO\n"
"    pathlib.Path(\"example.txt\").write_text(\"hello world\", encoding=\"utf8\")\n"
"\n"
"    # Create a coroutine\n"
"    coro = asyncio.sleep(1, result=3)\n"
"\n"
"    # Submit the coroutine to a given loop\n"
"    future = asyncio.run_coroutine_threadsafe(coro, loop)\n"
"\n"
"    # Wait for the result with an optional timeout argument\n"
"    assert future.result(timeout=2) == 3\n"
"\n"
"async def amain() -> None:\n"
"    # Get the running loop\n"
"    loop = asyncio.get_running_loop()\n"
"\n"
"    # Run something in a thread\n"
"    await asyncio.to_thread(in_thread, loop)"

msgid "It's also possible to run the other way around.  Example::"
msgstr "همچنین می‌توان آن را به‌صورت معکوس اجرا کرد. مثال::"

msgid ""
"@contextlib.contextmanager\n"
"def loop_in_thread() -> Generator[asyncio.AbstractEventLoop]:\n"
"    loop_fut = concurrent.futures.Future[asyncio.AbstractEventLoop]()\n"
"    stop_event = asyncio.Event()\n"
"\n"
"    async def main() -> None:\n"
"        loop_fut.set_result(asyncio.get_running_loop())\n"
"        await stop_event.wait()\n"
"\n"
"    with concurrent.futures.ThreadPoolExecutor(1) as tpe:\n"
"        complete_fut = tpe.submit(asyncio.run, main())\n"
"        for fut in concurrent.futures.as_completed((loop_fut, complete_fut)):\n"
"            if fut is loop_fut:\n"
"                loop = loop_fut.result()\n"
"                try:\n"
"                    yield loop\n"
"                finally:\n"
"                    loop.call_soon_threadsafe(stop_event.set)\n"
"            else:\n"
"                fut.result()\n"
"\n"
"# Create a loop in another thread\n"
"with loop_in_thread() as loop:\n"
"    # Create a coroutine\n"
"    coro = asyncio.sleep(1, result=3)\n"
"\n"
"    # Submit the coroutine to a given loop\n"
"    future = asyncio.run_coroutine_threadsafe(coro, loop)\n"
"\n"
"    # Wait for the result with an optional timeout argument\n"
"    assert future.result(timeout=2) == 3"
msgstr ""
"@contextlib.contextmanager\n"
"def loop_in_thread() -> Generator[asyncio.AbstractEventLoop]:\n"
"    loop_fut = concurrent.futures.Future[asyncio.AbstractEventLoop]()\n"
"    stop_event = asyncio.Event()\n"
"\n"
"    async def main() -> None:\n"
"        loop_fut.set_result(asyncio.get_running_loop())\n"
"        await stop_event.wait()\n"
"\n"
"    with concurrent.futures.ThreadPoolExecutor(1) as tpe:\n"
"        complete_fut = tpe.submit(asyncio.run, main())\n"
"        for fut in concurrent.futures.as_completed((loop_fut, complete_fut)):\n"
"            if fut is loop_fut:\n"
"                loop = loop_fut.result()\n"
"                try:\n"
"                    yield loop\n"
"                finally:\n"
"                    loop.call_soon_threadsafe(stop_event.set)\n"
"            else:\n"
"                fut.result()\n"
"\n"
"# Create a loop in another thread\n"
"with loop_in_thread() as loop:\n"
"    # Create a coroutine\n"
"    coro = asyncio.sleep(1, result=3)\n"
"\n"
"    # Submit the coroutine to a given loop\n"
"    future = asyncio.run_coroutine_threadsafe(coro, loop)\n"
"\n"
"    # Wait for the result with an optional timeout argument\n"
"    assert future.result(timeout=2) == 3"

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

msgid ""
"try:\n"
"    result = future.result(timeout)\n"
"except TimeoutError:\n"
"    print('The coroutine took too long, cancelling the task...')\n"
"    future.cancel()\n"
"except Exception as exc:\n"
"    print(f'The coroutine raised an exception: {exc!r}')\n"
"else:\n"
"    print(f'The coroutine returned: {result!r}')"
msgstr ""
"try:\n"
"    result = future.result(timeout)\n"
"except TimeoutError:\n"
"    print('The coroutine took too long, cancelling the task...')\n"
"    future.cancel()\n"
"except Exception as exc:\n"
"    print(f'The coroutine raised an exception: {exc!r}')\n"
"else:\n"
"    print(f'The coroutine returned: {result!r}')"

msgid "See the :ref:`concurrency and multithreading <asyncio-multithreading>` section of the documentation."
msgstr "بخش :ref:`همروندی و چندریسمانی <asyncio-multithreading>` مستندات را ببینید."

msgid "Unlike other asyncio functions this function requires the *loop* argument to be passed explicitly."
msgstr "برخلاف سایر توابع asyncio، این تابع نیاز دارد که آرگومان *loop* به‌صورت صریح ارسال شود."

msgid "Introspection"
msgstr "درون‌نگری"

msgid "Return the currently running :class:`Task` instance, or ``None`` if no task is running."
msgstr "نمونه‌ی در حال اجرای :class:`Task` را برمی‌گرداند، یا اگر هیچ وظیفه‌ای در حال اجرا نباشد، ``None`` را برمی‌گرداند."

msgid "If *loop* is ``None`` :func:`get_running_loop` is used to get the current loop."
msgstr "اگر *loop* برابر ``None`` باشد، از :func:`get_running_loop` برای گرفتن حلقه جاری استفاده می‌شود."

msgid "Return a set of not yet finished :class:`Task` objects run by the loop."
msgstr "مجموعه‌ای از اشیاء :class:`Task` که هنوز تمام‌نشده‌اند و توسط حلقه اجرا می‌شوند را برمی‌گرداند."

msgid "If *loop* is ``None``, :func:`get_running_loop` is used for getting current loop."
msgstr "اگر *loop* برابر ``None`` باشد، برای گرفتن حلقه‌ی جاری از :func:`get_running_loop` استفاده می‌شود."

msgid "Return ``True`` if *obj* is a coroutine object."
msgstr "اگر *obj* یک شیء هم‌روال باشد، ``True`` برمی‌گرداند."

msgid "Task object"
msgstr "شیء Task"

msgid "A :class:`Future-like <Future>` object that runs a Python :ref:`coroutine <coroutine>`.  Not thread-safe."
msgstr "یک شیء :class:`Future-مانند <Future>` که یک :ref:`هم‌روال <coroutine>` پایتون را اجرا می‌کند. نخ‌ایمن نیست."

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ها برای اجرای هم‌روال‌ها در حلقه‌های رویداد استفاده می‌شود. اگر یک هم‌روال روی یک Future await کند، Task اجرای هم‌روال را معلق می‌کند و منتظر کامل شدن Future می‌ماند. هنگامی که Future *انجام‌شده* باشد، اجرای هم‌روال دربرگرفته‌شده از سر گرفته می‌شود."

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 "حلقه‌های رویداد از زمان‌بندی مشارکتی استفاده می‌کنند: یک حلقه رویداد در هر زمان یک Task را اجرا می‌کند. هنگامی که یک Task برای تکمیل شدن یک Future await می‌کند، حلقه رویداد Taskهای دیگر و کال‌بک‌ها را اجرا می‌کند یا عملیات ورودی/خروجی انجام می‌دهد."

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` استفاده کنید. نمونه‌سازی دستی Taskها توصیه نمی‌شود."

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 "برای لغو یک Task در حال اجرا، از متد :meth:`cancel` استفاده کنید. فراخوانی آن موجب می‌شود که Task استثنای :exc:`CancelledError` را به درون هم‌روال پوشیده‌شده پرتاب کند. اگر یک هم‌روال در حین لغو، روی یک شیء Future در حال await باشد، شیء Future لغو خواهد شد."

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` برای بررسی این‌که Task لغو شده است یا خیر استفاده کنید. اگر هم‌روال پوشیده‌شده استثنای :exc:`CancelledError` را سرکوب نکرده باشد و واقعاً لغو شده باشد، این متد ``True`` برمی‌گرداند."

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` از :class:`Future` همه‌ی APIهای آن را به ارث می‌برد، به‌جز :meth:`Future.set_result` و :meth:`Future.set_exception`."

msgid "An optional keyword-only *context* argument allows specifying a custom :class:`contextvars.Context` for the *coro* to run in. If no *context* is provided, the Task copies the current context and later runs its coroutine in the copied context."
msgstr "یک آرگومان *context* اختیاری فقط کلیدواژه‌ای به شما امکان می‌دهد یک :class:`contextvars.Context` سفارشی را برای اجرای *coro* در آن تعیین کنید. اگر *context* ارائه نشود، Task زمینه جاری را کپی می‌کند و بعداً هم‌روال خود را در زمینه کپی‌شده اجرا می‌کند."

msgid "An optional keyword-only *eager_start* argument allows eagerly starting the execution of the :class:`asyncio.Task` at task creation time. If set to ``True`` and the event loop is running, the task will start executing the coroutine immediately, until the first time the coroutine blocks. If the coroutine returns or raises without blocking, the task will be finished eagerly and will skip scheduling to the event loop."
msgstr "یک آرگومان اختیاری و فقط کلیدواژه‌ای به نام *eager_start* امکان شروع فوری اجرای :class:`asyncio.Task` را در زمان ایجاد وظیفه فراهم می‌کند. اگر روی ``True`` تنظیم شده باشد و حلقه رویداد در حال اجرا باشد، وظیفه اجرای هم‌روال را بلافاصله آغاز می‌کند، تا نخستین باری که هم‌روال مسدود شود. اگر هم‌روال بدون مسدود شدن بازگشت کند یا استثنایی پرتاب کند، وظیفه به‌صورت فوری به پایان می‌رسد و در حلقه رویداد زمان‌بندی نمی‌شود."

msgid "Tasks are :ref:`generic <generics>` over the return type of their wrapped coroutines."
msgstr "وظایف نسبت به نوع برگشتی هم‌روال‌های دربرگرفته‌شده‌ی خود :ref:`عام <generics>` هستند."

msgid "Added support for the :mod:`contextvars` module."
msgstr "پشتیبانی از ماژول :mod:`contextvars` افزوده شد."

msgid "Deprecation warning is emitted if *loop* is not specified and there is no running event loop."
msgstr "اگر *loop* مشخص نشده باشد و هیچ حلقه رویدادی در حال اجرا وجود نداشته باشد، هشدار منسوخ‌شدن نشان داده می‌شود."

msgid "Added the *eager_start* parameter."
msgstr "پارامتر *eager_start* اضافه شد."

msgid "Return ``True`` if the Task is *done*."
msgstr "اگر Task *انجام‌شده* باشد، ``True`` را برمی‌گرداند."

msgid "A Task is *done* when the wrapped coroutine either returned a value, raised an exception, or the Task was cancelled."
msgstr "یک وظیفه زمانی *انجام‌شده* است که هم‌روال دربرگرفته‌شده‌ی آن، یا مقداری را برگردانده باشد، یا استثنایی را پرتاب کرده باشد، یا آن وظیفه لغو شده باشد."

msgid "Return the result of the Task."
msgstr "نتیجه‌ی Task را برمی‌گرداند."

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 *انجام‌شده* باشد، نتیجه هم‌روال پوشیده‌شده برگردانده می‌شود (یا اگر هم‌روال استثنایی را پرتاب کرده باشد، آن استثنا دوباره پرتاب می‌شود.)"

msgid "If the Task has been *cancelled*, this method raises a :exc:`CancelledError` exception."
msgstr "اگر Task *لغوشده* باشد، این متد استثنای :exc:`CancelledError` را پرتاب می‌کند."

msgid "If the Task's result isn't yet available, this method raises an :exc:`InvalidStateError` exception."
msgstr "اگر نتیجه‌ی Task هنوز در دسترس نباشد، این متد یک استثنای :exc:`InvalidStateError` پرتاب می‌کند."

msgid "Return the exception of the Task."
msgstr "استثنای Task را برمی‌گرداند."

msgid "If the wrapped coroutine raised an exception that exception is returned.  If the wrapped coroutine returned normally this method returns ``None``."
msgstr "اگر هم‌روال پوشیده‌شده استثنایی پرتاب کرد، آن استثنا برگردانده می‌شود. اگر هم‌روال پوشیده‌شده به‌طور عادی بازگشت کرد، این متد ``None`` را برمی‌گرداند."

msgid "If the Task isn't *done* yet, this method raises an :exc:`InvalidStateError` exception."
msgstr "اگر Task هنوز *انجام‌شده* نباشد، این متد استثنای :exc:`InvalidStateError` را پرتاب می‌کند."

msgid "Add a callback to be run when the Task is *done*."
msgstr "یک کال‌بک اضافه کنید تا هنگامی که Task *انجام‌شده* باشد اجرا شود."

msgid "This method should only be used in low-level callback-based code."
msgstr "این متد تنها باید در کد سطح پایین مبتنی بر کال‌بک استفاده شود."

msgid "See the documentation of :meth:`Future.add_done_callback` for more details."
msgstr "برای جزئیات بیشتر، مستندات :meth:`Future.add_done_callback` را ببینید."

msgid "Remove *callback* from the callbacks list."
msgstr "*callback* را از فهرست کال‌بک‌ها حذف کنید."

msgid "See the documentation of :meth:`Future.remove_done_callback` for more details."
msgstr "برای جزئیات بیشتر، به مستندات :meth:`Future.remove_done_callback` مراجعه کنید."

msgid "Return the list of stack frames for this Task."
msgstr "فهرست فریم‌های پشته (stack frames) برای این Task را برمی‌گرداند."

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

msgid "The frames are always ordered from oldest to newest."
msgstr "فریم‌ها همیشه از قدیمی‌ترین به جدیدترین مرتب شده‌اند."

msgid "Only one stack frame is returned for a suspended coroutine."
msgstr "تنها یک فریم پشته برای یک هم‌روال تعلیق‌شده برگردانده می‌شود."

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 مطابقت دارد.)"

msgid "Print the stack or traceback for this Task."
msgstr "پشته یا ردگیری پشته‌ی این Task را چاپ می‌کند."

msgid "This produces output similar to that of the traceback module for the frames retrieved by :meth:`get_stack`."
msgstr "این، خروجی مشابهی با خروجی ماژول traceback برای فریم‌های بازیابی‌شده توسط :meth:`get_stack` تولید می‌کند."

msgid "The *limit* argument is passed to :meth:`get_stack` directly."
msgstr "آرگومان *limit* مستقیماً به :meth:`get_stack` ارسال می‌شود."

msgid "The *file* argument is an I/O stream to which the output is written; by default output is written to :data:`sys.stdout`."
msgstr "آرگومان *file* یک جریان ورودی/خروجی است که خروجی به آن نوشته می‌شود؛ به‌طور پیش‌فرض خروجی به :data:`sys.stdout` نوشته می‌شود."

msgid "Return the coroutine object wrapped by the :class:`Task`."
msgstr "شیء هم‌روالِ دربرگرفته‌شده توسط :class:`Task` را برمی‌گرداند."

msgid "This will return ``None`` for Tasks which have already completed eagerly. See the :ref:`Eager Task Factory <eager-task-factory>`."
msgstr "این ``None`` را برای Taskهایی که از قبل به‌صورت حریصانه کامل شده‌اند، بازمی‌گرداند. :ref:`Eager Task Factory <eager-task-factory>` را ببینید."

msgid "Newly added eager task execution means result may be ``None``."
msgstr "اجرای مشتاقانه‌ی وظیفه (eager task execution) که به‌تازگی اضافه‌شده است، به این معناست که نتیجه ممکن است ``None`` باشد."

msgid "Return the :class:`contextvars.Context` object associated with the task."
msgstr "شیء :class:`contextvars.Context` مرتبط با وظیفه را برمی‌گرداند."

msgid "Return the name of the Task."
msgstr "نام Task را برمی‌گرداند."

msgid "If no name has been explicitly assigned to the Task, the default asyncio Task implementation generates a default name during instantiation."
msgstr "اگر نامی به‌طور صریح به Task اختصاص داده نشده باشد، پیاده‌سازی پیش‌فرض Task در asyncio، در هنگام نمونه‌سازی یک نام پیش‌فرض تولید می‌کند."

msgid "Set the name of the Task."
msgstr "نام Task را تنظیم کنید."

msgid "The *value* argument can be any object, which is then converted to a string."
msgstr "آرگومان *value* می‌تواند هر شیء‌ای باشد که سپس به رشته تبدیل می‌شود."

msgid "In the default Task implementation, the name will be visible in the :func:`repr` output of a task object."
msgstr "در پیاده‌سازی پیش‌فرض Task، نام در خروجی :func:`repr` یک شیء task قابل مشاهده خواهد بود."

msgid "Request the Task to be cancelled."
msgstr "درخواست لغو Task را بدهید."

msgid "If the Task is already *done* or *cancelled*, return ``False``, otherwise, return ``True``."
msgstr "اگر Task از پیش *انجام‌شده* یا *لغوشده* باشد، ``False`` را برمی‌گرداند، در غیر این صورت ``True`` را برمی‌گرداند."

msgid "The method arranges for a :exc:`CancelledError` exception to be thrown into the wrapped coroutine on the next cycle of the event loop."
msgstr "این متد ترتیبی می‌دهد که استثنای :exc:`CancelledError` در چرخه‌ی بعدی حلقه‌ی رویداد به هم‌روال پوشیده‌شده پرتاب شود."

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.  Should the coroutine nevertheless decide to suppress the cancellation, it needs to call :meth:`Task.uncancel` in addition to catching the exception."
msgstr "سپس هم‌روال این فرصت را دارد که پاک‌سازی کند یا حتی با مهار استثنا از طریق یک بلوک :keyword:`try` ... ... ``except CancelledError`` ... :keyword:`finally`، درخواست را رد کند. بنابراین، برخلاف :meth:`Future.cancel`، :meth:`Task.cancel` تضمین نمی‌کند که Task لغو شود، اگرچه مهار کامل لغو رایج نیست و به‌طور فعال نهی شده است. اگر هم‌روال با این حال تصمیم بگیرد لغو را مهار کند، باید علاوه بر گرفتن استثنا، :meth:`Task.uncancel` را نیز فراخوانی کند."

msgid "Added the *msg* parameter."
msgstr "پارامتر *msg* اضافه شد."

msgid "The ``msg`` parameter is propagated from cancelled task to its awaiter."
msgstr "پارامتر ``msg`` از وظیفه لغوشده به awaitکننده‌ی آن منتقل می‌شود."

msgid "The following example illustrates how coroutines can intercept the cancellation request::"
msgstr "مثال زیر نشان می‌دهد که هم‌روال‌ها چگونه می‌توانند درخواست لغو را رهگیری کنند::"

msgid ""
"async def cancel_me():\n"
"    print('cancel_me(): before sleep')\n"
"\n"
"    try:\n"
"        # Wait for 1 hour\n"
"        await asyncio.sleep(3600)\n"
"    except asyncio.CancelledError:\n"
"        print('cancel_me(): cancel sleep')\n"
"        raise\n"
"    finally:\n"
"        print('cancel_me(): after sleep')\n"
"\n"
"async def main():\n"
"    # Create a \"cancel_me\" Task\n"
"    task = asyncio.create_task(cancel_me())\n"
"\n"
"    # Wait for 1 second\n"
"    await asyncio.sleep(1)\n"
"\n"
"    task.cancel()\n"
"    try:\n"
"        await task\n"
"    except asyncio.CancelledError:\n"
"        print(\"main(): cancel_me is cancelled now\")\n"
"\n"
"asyncio.run(main())\n"
"\n"
"# Expected output:\n"
"#\n"
"#     cancel_me(): before sleep\n"
"#     cancel_me(): cancel sleep\n"
"#     cancel_me(): after sleep\n"
"#     main(): cancel_me is cancelled now"
msgstr ""
"async def cancel_me():\n"
"    print('cancel_me(): before sleep')\n"
"\n"
"    try:\n"
"        # Wait for 1 hour\n"
"        await asyncio.sleep(3600)\n"
"    except asyncio.CancelledError:\n"
"        print('cancel_me(): cancel sleep')\n"
"        raise\n"
"    finally:\n"
"        print('cancel_me(): after sleep')\n"
"\n"
"async def main():\n"
"    # Create a \"cancel_me\" Task\n"
"    task = asyncio.create_task(cancel_me())\n"
"\n"
"    # Wait for 1 second\n"
"    await asyncio.sleep(1)\n"
"\n"
"    task.cancel()\n"
"    try:\n"
"        await task\n"
"    except asyncio.CancelledError:\n"
"        print(\"main(): cancel_me is cancelled now\")\n"
"\n"
"asyncio.run(main())\n"
"\n"
"# Expected output:\n"
"#\n"
"#     cancel_me(): before sleep\n"
"#     cancel_me(): cancel sleep\n"
"#     cancel_me(): after sleep\n"
"#     main(): cancel_me is cancelled now"

msgid "Return ``True`` if the Task is *cancelled*."
msgstr "اگر Task *لغوشده* باشد، ``True`` را برمی‌گرداند."

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 "Task زمانی *لغو می‌شود* که لغو با :meth:`cancel` درخواست شده باشد و هم‌روال دربرگرفته‌شده، استثنای :exc:`CancelledError` پرتاب‌شده به درون آن را منتشر کرده باشد."

msgid "Decrement the count of cancellation requests to this Task."
msgstr "شمار درخواست‌های لغو برای این Task را کاهش می‌دهد."

msgid "Returns the remaining number of cancellation requests."
msgstr "تعداد باقی‌مانده‌ی درخواست‌های لغو را برمی‌گرداند."

msgid "Note that once execution of a cancelled task completed, further calls to :meth:`uncancel` are ineffective."
msgstr "توجه داشته باشید که پس از کامل شدن اجرای یک وظیفه‌ی لغوشده، فراخوانی‌های بعدی :meth:`uncancel` بی‌اثر خواهند بود."

msgid "This method is used by asyncio's internals and isn't expected to be used by end-user code.  In particular, if a Task gets successfully uncancelled, this allows for elements of structured concurrency like :ref:`taskgroups` and :func:`asyncio.timeout` to continue running, isolating cancellation to the respective structured block. For example::"
msgstr "این متد توسط بخش‌های داخلی asyncio استفاده می‌شود و انتظار نمی‌رود توسط کد کاربر نهایی استفاده شود. به‌ویژه، اگر یک Task با موفقیت از حالت لغو خارج شود، این امر به عناصر همروندی ساختاریافته (structured concurrency) مانند :ref:`taskgroups` و :func:`asyncio.timeout` اجازه می‌دهد به اجرای خود ادامه دهند و لغو را به بلوک ساختاریافته مربوطه محدود کنند. برای مثال::"

msgid ""
"async def make_request_with_timeout():\n"
"    try:\n"
"        async with asyncio.timeout(1):\n"
"            # Structured block affected by the timeout:\n"
"            await make_request()\n"
"            await make_another_request()\n"
"    except TimeoutError:\n"
"        log(\"There was a timeout\")\n"
"    # Outer code not affected by the timeout:\n"
"    await unrelated_code()"
msgstr ""
"async def make_request_with_timeout():\n"
"    try:\n"
"        async with asyncio.timeout(1):\n"
"            # Structured block affected by the timeout:\n"
"            await make_request()\n"
"            await make_another_request()\n"
"    except TimeoutError:\n"
"        log(\"There was a timeout\")\n"
"    # Outer code not affected by the timeout:\n"
"    await unrelated_code()"

msgid "While the block with ``make_request()`` and ``make_another_request()`` might get cancelled due to the timeout, ``unrelated_code()`` should continue running even in case of the timeout.  This is implemented with :meth:`uncancel`.  :class:`TaskGroup` context managers use :func:`uncancel` in a similar fashion."
msgstr "در حالی که ممکن است بلوک حاوی ``make_request()`` و ``make_another_request()`` به دلیل مهلت زمانی لغو شود، ``unrelated_code()`` باید حتی در صورت وقوع مهلت زمانی به اجرای خود ادامه دهد. این کار با :meth:`uncancel` پیاده‌سازی شده است. مدیران زمینه :class:`TaskGroup` از :func:`uncancel` به شیوه‌ای مشابه استفاده می‌کنند."

msgid "If end-user code is, for some reason, suppressing cancellation by catching :exc:`CancelledError`, it needs to call this method to remove the cancellation state."
msgstr "اگر کد کاربر نهایی به هر دلیلی با گرفتن :exc:`CancelledError` لغو را مهار می‌کند، باید این متد را فراخوانی کند تا وضعیت لغو را حذف کند."

msgid "When this method decrements the cancellation count to zero, the method checks if a previous :meth:`cancel` call had arranged for :exc:`CancelledError` to be thrown into the task. If it hasn't been thrown yet, that arrangement will be rescinded (by resetting the internal ``_must_cancel`` flag)."
msgstr "هنگامی که این متد شمار لغو را به صفر کاهش می‌دهد، متد بررسی می‌کند که آیا یک فراخوانی پیشین :meth:`cancel` ترتیبی برای پرتاب :exc:`CancelledError` به درون وظیفه داده بود یا خیر. اگر هنوز پرتاب نشده باشد، آن ترتیب لغو خواهد شد (با بازنشانی پرچم داخلی ``_must_cancel``)."

msgid "Changed to rescind pending cancellation requests upon reaching zero."
msgstr "تغییر کرد تا درخواست‌های لغو در انتظار، پس از رسیدن به صفر پس گرفته شوند."

msgid "Return the number of pending cancellation requests to this Task, i.e., the number of calls to :meth:`cancel` less the number of :meth:`uncancel` calls."
msgstr "تعداد درخواست‌های لغو در انتظار برای این Task را برمی‌گرداند، یعنی تعداد فراخوانی‌های :meth:`cancel` منهای تعداد فراخوانی‌های :meth:`uncancel`."

msgid "Note that if this number is greater than zero but the Task is still executing, :meth:`cancelled` will still return ``False``. This is because this number can be lowered by calling :meth:`uncancel`, which can lead to the task not being cancelled after all if the cancellation requests go down to zero."
msgstr "توجه داشته باشید که اگر این عدد بزرگ‌تر از صفر باشد اما Task هنوز در حال اجرا باشد، :meth:`cancelled` همچنان ``False`` را برمی‌گرداند. این به این دلیل است که این عدد می‌تواند با فراخوانی :meth:`uncancel` کاهش یابد، که اگر درخواست‌های لغو به صفر برسند، ممکن است در نهایت منجر به لغو نشدن Task شود."

msgid "This method is used by asyncio's internals and isn't expected to be used by end-user code.  See :meth:`uncancel` for more details."
msgstr "این متد توسط اجزای داخلی asyncio استفاده می‌شود و انتظار نمی‌رود که توسط کد کاربر نهایی استفاده شود. برای جزئیات بیشتر :meth:`uncancel` را ببینید."