@@ -11,7 +11,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: Python 3.14\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2026-10-01 14:41+0330\n"
+"POT-Creation-Date: 2026-10-13 04:22+0000\n"
 "PO-Revision-Date: 2026-09-21 13:27+0330\n"
 "Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"
 "Language-Team: none\n"
@@ -868,18 +868,30 @@ msgstr "استفاده از عملگر وارون‌سازی بیتی ``~`` من
 msgid ":class:`bool` is a subclass of :class:`int` (see :ref:`typesnumeric`). In many numeric contexts, ``False`` and ``True`` behave like the integers 0 and 1, respectively. However, relying on this is discouraged; explicitly convert using :func:`int` instead."
 msgstr ":class:`bool` زیرکلاسی از :class:`int` است (به :ref:`typesnumeric` مراجعه کنید). در بسیاری از زمینه‌های عددی، ``False`` و ``True`` مانند اعداد صحیح ۰ و ۱ رفتار می‌کنند. با این حال، تکیه بر این موضوع توصیه نمی‌شود؛ به جای آن، صریحاً با استفاده از :func:`int` تبدیل کنید."
 
-msgid "Iterator Types"
+#, fuzzy
+#| msgid "Iterator Types"
+msgid "Iteration-related types"
 msgstr "انواع پیمایش‌گر"
 
 msgid "Python supports a concept of iteration over containers.  This is implemented using two distinct methods; these are used to allow user-defined classes to support iteration.  Sequences, described below in more detail, always support the iteration methods."
 msgstr "پایتون از مفهومی به نام پیمایش روی ظرف‌ها (containers) پشتیبانی می‌کند. این مفهوم با استفاده از دو متد متمایز پیاده‌سازی می‌شود؛ از این متدها استفاده می‌شود تا کلاس‌های تعریف‌شده توسط کاربر بتوانند از پیمایش پشتیبانی کنند. دنباله‌ها، که در ادامه با جزئیات بیشتری توضیح داده می‌شوند، همواره از متدهای تکرار پشتیبانی می‌کنند."
 
+#, fuzzy
+#| msgid "literals"
+msgid "Iterables"
+msgstr "مقادیر لفظی"
+
 msgid "One method needs to be defined for container objects to provide :term:`iterable` support:"
 msgstr "برای آنکه اشیاء ظرف بتوانند پشتیبانی از :term:`پیمایش‌پذیر <iterable>` را فراهم کنند، باید یک متد تعریف شود:"
 
 msgid "Return an :term:`iterator` object.  The object is required to support the iterator protocol described below.  If a container supports different types of iteration, additional methods can be provided to specifically request iterators for those iteration types.  (An example of an object supporting multiple forms of iteration would be a tree structure which supports both breadth-first and depth-first traversal.)  This method corresponds to the :c:member:`~PyTypeObject.tp_iter` slot of the type structure for Python objects in the Python/C API."
 msgstr "یک شیء :term:`پیمایش‌گر <iterator>` بازمی‌گرداند. این شیء موظف است از پروتکل پیمایش‌گری که در ادامه شرح داده شده است پشتیبانی کند. اگر یک ظرف از انواع مختلف تکرار پشتیبانی می‌کند، می‌توان متدهای اضافی‌ای ارائه داد که به‌طور خاص برای آن انواع تکرار، پیمایش‌گر درخواست کنند. (نمونه‌ای از شیءای که از چند شکل پیمایش پشتیبانی می‌کند، ساختاری درختی است که هم پیمایش عرضی (breadth-first) و هم پیمایش عمقی (depth-first) را پشتیبانی می‌کند.) این متد متناظر با جایگاه :c:member:`~PyTypeObject.tp_iter` در ساختار نوع اشیاء پایتون در Python/C API است."
 
+#, fuzzy
+#| msgid "iterator"
+msgid "Iterators"
+msgstr "پیمایش‌گر"
+
 msgid "The iterator objects themselves are required to support the following two methods, which together form the :dfn:`iterator protocol`:"
 msgstr "خود اشیاء پیمایش‌گر ملزم به پشتیبانی از دو متد زیر هستند که در مجموع :dfn:`پروتکل پیمایش‌گر (iterator protocol)` را تشکیل می‌دهند:"
 
@@ -895,11 +907,167 @@ msgstr "پایتون چندین شیء پیمایش‌گر تعریف می‌ک
 msgid "Once an iterator's :meth:`~iterator.__next__` method raises :exc:`StopIteration`, it must continue to do so on subsequent calls. Implementations that do not obey this property are deemed broken."
 msgstr "به‌محض اینکه متد :meth:`~iterator.__next__` یک پیمایش‌گر استثنای :exc:`StopIteration` را پرتاب کند، باید به انجام همین کار در فراخوانی‌های بعدی ادامه دهد. پیاده‌سازی‌هایی که از این ویژگی پیروی نمی‌کنند، معیوب تلقی می‌شوند."
 
-msgid "Generator Types"
+#, fuzzy
+#| msgid "Generator Types"
+msgid "Generator types"
 msgstr "انواع تولیدگر"
 
-msgid "Python's :term:`generator`\\s provide a convenient way to implement the iterator protocol.  If a container object's :meth:`~object.__iter__` method is implemented as a generator, it will automatically return an iterator object (technically, a generator object) supplying the :meth:`~iterator.__iter__` and :meth:`~generator.__next__` methods. More information about generators can be found in :ref:`the documentation for the yield expression <yieldexpr>`."
-msgstr ":term:`تولیدگرهای <generator>` پایتون راهی مناسب برای پیاده‌سازی پروتکل پیمایش‌گر فراهم می‌کنند. اگر متد :meth:`~object.__iter__` یک شیء ظرف به‌صورت یک تولیدگر پیاده‌سازی شود، به‌طور خودکار یک شیء پیمایش‌گر (از نظر فنی، یک شیء تولیدگر) بازمی‌گرداند که متدهای :meth:`~iterator.__iter__` و :meth:`~generator.__next__` را فراهم می‌کند. اطلاعات بیشتری درباره تولیدگرها می‌توانید در :ref:`مستندات عبارت yield <yieldexpr>` بیابید."
+msgid "Python's :term:`generators <generator>` -- or more precisely, :term:`generator functions <generator function>` and :term:`generator iterators <generator iterator>` -- provide a convenient way to implement the iterator protocol."
+msgstr ""
+
+msgid "A function that contains one or more :ref:`yield expressions <yieldexpr>` is a :term:`generator function`. For example::"
+msgstr ""
+
+msgid ""
+">>> def count_to_three():\n"
+"...     yield 0\n"
+"...     yield 1\n"
+"...     yield 2\n"
+"...     yield 3"
+msgstr ""
+
+msgid "Generator functions behave as regular :ref:`user-defined functions <user-defined-funcs>` (for example, they have the same attributes), except that calling a generator function returns a :ref:`generator iterator <generator-methods>`::"
+msgstr ""
+
+msgid ""
+">>> count_to_three()\n"
+"<generator object count_to_three at 0x7f33a2305000>"
+msgstr ""
+
+msgid "Iterating a generator iterator executes code of the underlying generator function, producing each :keyword:`yield`\\ed value in turn::"
+msgstr ""
+
+msgid ""
+">>> for number in count_to_three():\n"
+"...     print(number)\n"
+"0\n"
+"1\n"
+"2\n"
+"3\n"
+"\n"
+">>> list(count_to_three())\n"
+"[0, 1, 2, 3]"
+msgstr ""
+
+msgid "One common use for generator functions is implementing the :meth:`~object.__iter__` method of custom iterable objects. For example::"
+msgstr ""
+
+msgid ""
+">>> class CardDeck:\n"
+"...     def __iter__(self):\n"
+"...         yield 'three of clubs'\n"
+"...         yield 'ace of hearts'\n"
+"\n"
+">>> list(CardDeck())\n"
+"['three of clubs', 'ace of hearts']"
+msgstr ""
+
+#, fuzzy
+#| msgid "Generator Types"
+msgid "Generator iterators"
+msgstr "انواع تولیدگر"
+
+msgid "Generator iterators implement the :ref:`iterator protocol <stdtypes-iterators>`. Iterating them drives execution of the underlying generator function."
+msgstr ""
+
+msgid "Starts the execution of a generator function or resumes it at the :ref:`yield expression <yieldexpr>` where the function is currently suspended. When a generator function is resumed with a :meth:`~generator.__next__` method, the current yield expression always evaluates to :const:`None`. The execution then continues to the next yield expression, where the generator is suspended again, and the value of the expression after the :keyword:`yield` keyword is returned to :meth:`~generator.__next__`'s caller. If the generator exits without yielding another value, :meth:`~generator.__next__` raises a :exc:`StopIteration` exception, signalling that iteration has completed."
+msgstr ""
+
+msgid "This method is normally called implicitly, for example by a :keyword:`for` loop, or by the built-in :func:`next` function."
+msgstr ""
+
+msgid "Generator iterators have a few more methods than generic iterators, which can be used to control the execution of the underlying generator function:"
+msgstr ""
+
+msgid "\"Sends\" a value into the generator function: the *value* argument becomes the result of the current yield expression."
+msgstr ""
+
+msgid "Otherwise, this method behaves like :meth:`~generator.__next__`: it resumes the underlying function and either returns the next yielded value or raises :exc:`StopIteration`."
+msgstr ""
+
+msgid "When :meth:`send` is called to start the generator, it must be called with :const:`None` as the argument, because there is no current yield expression that could receive the value."
+msgstr ""
+
+msgid "Raises an exception at the point where the generator is currently suspended."
+msgstr ""
+
+msgid "Otherwise, this method behaves like :meth:`~generator.__next__`: it resumes the underlying function and either returns the next yielded value or raises :exc:`StopIteration`. If the generator function does not catch the passed-in exception, or raises a different exception, then that exception propagates to the caller."
+msgstr ""
+
+msgid "When :meth:`throw` is called to start the generator, the generator immediately exits (that is, subsequent calls to :meth:`~generator.__next__` will raise :exc:`StopIteration`) and the thrown exception is propagated to :meth:`throw`'s caller."
+msgstr ""
+
+msgid "In typical use, this is called with a single argument, an exception instance, similar to the way the :keyword:`raise` keyword is used."
+msgstr ""
+
+msgid "For backwards compatibility, however, the second signature is supported, following a convention from older versions of Python. The *type* argument should be an exception class, and *value* should be an exception instance. If the *value* is not provided, the *type* constructor is called to get an instance. If *traceback* is provided, it is set on the exception, otherwise any existing :attr:`~BaseException.__traceback__` attribute stored in *value* may be cleared."
+msgstr ""
+
+msgid "The second signature \\(type\\[, value\\[, traceback\\]\\]\\) is deprecated and may be removed in a future version of Python."
+msgstr ""
+
+msgid "Raises a :exc:`GeneratorExit` exception at the point where the generator function is currently suspended (equivalent to calling ``throw(GeneratorExit)``)."
+msgstr ""
+
+msgid "If the generator function has already exited (due to an exception or normal return), or raises :exc:`GeneratorExit` (by not catching the exception), :meth:`close` returns :const:`None`. If the generator yields a value, a :exc:`RuntimeError` is raised. If the generator raises any other exception, it is propagated to the caller. If a generator returns a value upon being closed, that value is returned by :meth:`close`."
+msgstr ""
+
+msgid "When a generator iterator is garbage collected before it has exited, :meth:`~generator.close` is called automatically."
+msgstr ""
+
+msgid "If a generator returns a value upon being closed, the value is returned by :meth:`close`. Previously, it returned ``None``."
+msgstr ""
+
+msgid "Calling any of the generator methods (:meth:`~generator.__next__`, :meth:`~generator.send`, :meth:`~generator.throw`, :meth:`~generator.close`) while one of these methods is already executing raises a :exc:`ValueError` exception."
+msgstr ""
+
+msgid "Asynchronous generator iterators"
+msgstr ""
+
+msgid "This subsection describes the methods of an asynchronous generator iterator, which are used to control the execution of an asynchronous generator function."
+msgstr ""
+
+msgid "Returns an :term:`awaitable` which when run starts to execute the asynchronous generator function or resumes it at the :ref:`yield expression <yieldexpr>` where the function is currently suspended. When an asynchronous generator function is resumed with an :meth:`~agen.__anext__` method, the current yield expression always evaluates to :const:`None` in the returned awaitable, which when run will continue to the next yield expression. The value of the expression after the :keyword:`yield` keyword is the value of the :exc:`StopIteration` exception raised by the completing coroutine. If the asynchronous generator exits without yielding another value, the awaitable instead raises a :exc:`StopAsyncIteration` exception, signalling that the asynchronous iteration has completed."
+msgstr ""
+
+msgid "This method is normally called implicitly by an :keyword:`async for` loop, or by the built-in :func:`anext` function."
+msgstr ""
+
+msgid "Asynchronous generator-iterators have a few more methods than generic asynchronous iterators, which can be used to control the execution of the underlying generator function:"
+msgstr ""
+
+msgid "Returns an awaitable which, when run, \"sends\" a value into the underlying asynchronous generator function: the *value* argument becomes the result of the current yield expression."
+msgstr ""
+
+msgid "Otherwise, this method behaves like :meth:`~agen.__anext__`: when the returned awaitable runs, it resumes the underlying function and either returns the next yielded value as the value of the raised :exc:`StopIteration`, or raises :exc:`StopAsyncIteration`."
+msgstr ""
+
+msgid "When :meth:`asend` is called to start the asynchronous generator, it must be called with :const:`None` as the argument, because there is no yield expression that could receive the value."
+msgstr ""
+
+msgid "Returns an awaitable that, when run, raises an exception at the point where the underlying asynchronous generator function is currently suspended."
+msgstr ""
+
+msgid "Otherwise, this method behaves like :meth:`~agen.__anext__`: when the returned awaitable runs, it resumes the underlying function (with an exception raised) and either returns the next yielded value as the value of the raised :exc:`StopIteration`, or raises :exc:`StopAsyncIteration`. If the underlying function does not catch the passed-in exception, or raises a different exception, then when the awaitable is run, that exception propagates to the caller of the awaitable."
+msgstr ""
+
+msgid "When :meth:`~agen.athrow` is called to start the generator, the generator exits when the awaitable runs (that is, subsequent results from :meth:`~agen.__anext__` will raise :exc:`StopAsyncIteration` when run) and the thrown exception is propagated to the awaitable's caller."
+msgstr ""
+
+msgid "For backwards compatibility, however, the second signature is supported. An exception instance is created from three arguments in the same way as in :meth:`generator.throw`."
+msgstr ""
+
+msgid "Returns an awaitable that when run will throw a :exc:`GeneratorExit` into the underlying asynchronous generator function at the point where it is currently suspended (equivalent to calling ``athrow(GeneratorExit)``)."
+msgstr ""
+
+msgid "If the asynchronous generator function then exits gracefully, is already closed, or raises :exc:`GeneratorExit` (by not catching the exception), then the returned awaitable will raise a :exc:`StopIteration` exception. Any further awaitables returned by subsequent calls to the asynchronous generator will raise a :exc:`StopAsyncIteration` exception."
+msgstr ""
+
+msgid "If the asynchronous generator yields a value, a :exc:`RuntimeError` is raised by the awaitable. If the asynchronous generator raises any other exception, that exception is propagated to the caller of the awaitable."
+msgstr ""
+
+msgid "If the asynchronous generator has already exited due to an exception or normal exit, then further calls to :meth:`aclose` will return an awaitable that does nothing."
+msgstr ""
 
 msgid "Sequence Types --- :class:`list`, :class:`tuple`, :class:`range`"
 msgstr "انواع دنباله --- :class:`list`، :class:`tuple`، :class:`range`"
@@ -6455,6 +6623,34 @@ msgstr "ظرف"
 msgid "iteration over"
 msgstr "پیمایش روی"
 
+#, fuzzy
+#| msgid "operator"
+msgid "generator"
+msgstr "عملگر"
+
+#, fuzzy
+#| msgid "Description"
+msgid "exception"
+msgstr "توضیح"
+
+#, fuzzy
+#| msgid "operation"
+msgid "StopIteration"
+msgstr "عملیات"
+
+#, fuzzy
+#| msgid "Generator Types"
+msgid "GeneratorExit"
+msgstr "انواع تولیدگر"
+
+msgid "asynchronous-generator"
+msgstr ""
+
+#, fuzzy
+#| msgid "operation"
+msgid "StopAsyncIteration"
+msgstr "عملیات"
+
 msgid "len"
 msgstr "len"
 
@@ -6725,6 +6921,9 @@ msgstr "..."
 msgid "ellipsis literal"
 msgstr "لفظی سه‌نقطه"
 
+#~ msgid "Python's :term:`generator`\\s provide a convenient way to implement the iterator protocol.  If a container object's :meth:`~object.__iter__` method is implemented as a generator, it will automatically return an iterator object (technically, a generator object) supplying the :meth:`~iterator.__iter__` and :meth:`~generator.__next__` methods. More information about generators can be found in :ref:`the documentation for the yield expression <yieldexpr>`."
+#~ msgstr ":term:`تولیدگرهای <generator>` پایتون راهی مناسب برای پیاده‌سازی پروتکل پیمایش‌گر فراهم می‌کنند. اگر متد :meth:`~object.__iter__` یک شیء ظرف به‌صورت یک تولیدگر پیاده‌سازی شود، به‌طور خودکار یک شیء پیمایش‌گر (از نظر فنی، یک شیء تولیدگر) بازمی‌گرداند که متدهای :meth:`~iterator.__iter__` و :meth:`~generator.__next__` را فراهم می‌کند. اطلاعات بیشتری درباره تولیدگرها می‌توانید در :ref:`مستندات عبارت yield <yieldexpr>` بیابید."
+
 #~ msgid "Return a copy of the sequence with all occurrences of subsequence *old* replaced by *new*.  If the optional argument *count* is given, only the first *count* occurrences are replaced."
 #~ msgstr "یک کپی از دنباله را برمی‌گرداند که در آن تمام رخدادهای زیردنباله‌ی *old* با *new* جایگزین شده‌اند. اگر آرگومان اختیاری *count* داده شود، فقط *count* رخداد نخست جایگزین می‌شوند."