threadsafety.po

# Persian translations for Python package.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# Automatically generated, 2026.
#
# Translators:
# 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-19 20:08+0330\n"
"PO-Revision-Date: 2026-09-19 20:08+0330\n"
"Last-Translator: Sepehr Rasouli <sepehrrasouli06@gmail.com>, 2026\n"
"Language-Team: none\n"
"Language: fa\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"

msgid "Thread Safety Guarantees"
msgstr "تضمین‌های ایمنی نخ"

msgid "This page documents thread-safety guarantees for built-in types in Python's free-threaded build. The guarantees described here apply when using Python with the :term:`GIL` disabled (free-threaded mode). When the GIL is enabled, most operations are implicitly serialized."
msgstr "این صفحه تضمین‌های ایمنی نخی برای انواع توکار در ساخت نخ‌آزاد (free-threaded) پایتون را مستند می‌کند. تضمین‌های توصیف‌شده در اینجا زمانی اعمال می‌شوند که از پایتون با :term:`GIL` غیرفعال (حالت نخ‌آزاد) استفاده می‌کنید. هنگامی که GIL فعال باشد، بیشتر عملیات‌ها به‌طور ضمنی به‌صورت سریالی اجرا می‌شوند."

msgid "For general guidance on writing thread-safe code in free-threaded Python, see :ref:`freethreading-python-howto`."
msgstr "برای راهنمایی کلی درباره نوشتن کد نخ‌ایمن (thread-safe) در پایتون نخ‌آزاد، به :ref:`freethreading-python-howto` مراجعه کنید."

msgid "Thread safety levels"
msgstr "سطوح ایمنی نخ"

msgid "The C API documentation uses the following levels to describe the thread safety guarantees of each function. The levels are listed from least to most safe."
msgstr "مستندات C API از سطوح زیر برای توصیف تضمین‌های ایمنی نخی هر تابع استفاده می‌کند. این سطوح از کم‌ایمن‌ترین تا ایمن‌ترین فهرست شده‌اند."

msgid "Incompatible"
msgstr "ناسازگار"

msgid "A function or operation that cannot be made safe for concurrent use even with external synchronization. Incompatible code typically accesses global state in an unsynchronized way and must only be called from a single thread throughout the program's lifetime."
msgstr "تابع یا عملیاتی که حتی با همگام‌سازی خارجی نیز نمی‌توان آن را برای استفاده همزمان ایمن کرد. کد ناسازگار معمولاً به وضعیت سراسری به‌صورت همگام‌نشده دسترسی پیدا می‌کند و باید در طول عمر برنامه تنها از یک نخ فراخوانی شود."

msgid "Example: a function that modifies process-wide state such as signal handlers or environment variables, where concurrent calls from any threads, even with external locking, can conflict with the runtime or other libraries."
msgstr "مثال: تابعی که وضعیت سراسریِ فرایند را تغییر می‌دهد، مانند هندلرهای سیگنال یا متغیرهای محیطی، که در آن فراخوانی‌های همزمان از هر نخی، حتی با قفل‌گذاری خارجی، می‌توانند با ران‌تایم یا کتابخانه‌های دیگر تداخل داشته باشند."

msgid "Compatible"
msgstr "سازگار"

msgid "A function or operation that is safe to call from multiple threads *provided* the caller supplies appropriate external synchronization, for example by holding a :term:`lock` for the duration of each call. Without such synchronization, concurrent calls may produce :term:`race conditions <race condition>` or :term:`data races <data race>`."
msgstr "تابع یا عملیاتی که فراخوانی آن از چندین نخ ایمن است، *مشروط بر اینکه* فراخواننده همگام‌سازی خارجی مناسبی را فراهم کند، برای مثال با نگه‌داشتن یک :term:`قفل <lock>` در طول مدت هر فراخوانی. بدون چنین همگام‌سازی‌ای، فراخوانی‌های همزمان ممکن است باعث ایجاد :term:`شرایط رقابتی <race condition>` یا :term:`رقابت‌های داده‌ای <data race>` شوند."

msgid "Example: a function that reads from or writes to an object whose internal state is not protected by a lock. Callers must ensure that no two threads access the same object at the same time."
msgstr "مثال: تابعی که از یک شیء می‌خواند یا در آن می‌نویسد، و وضعیت داخلی آن شیء با یک قفل محافظت نمی‌شود. فراخوانی‌کنندگان باید اطمینان حاصل کنند که هیچ دو نخی به‌طور همزمان به همان شیء دسترسی نداشته باشند."

msgid "Safe on distinct objects"
msgstr "ایمن برای اشیاء متمایز"

msgid "A function or operation that is safe to call from multiple threads without external synchronization, as long as each thread operates on a **different** object. Two threads may call the function at the same time, but they must not pass the same object (or objects that share underlying state) as arguments."
msgstr "تابع یا عملیاتی که فراخوانی آن از چند نخ بدون همگام‌سازی خارجی امن است، مشروط بر اینکه هر نخ روی یک شیء **متفاوت** عمل کند. دو نخ می‌توانند تابع را همزمان فراخوانی کنند، اما نباید شیء یکسان (یا اشیایی که وضعیت زیربنایی مشترکی دارند) را به‌عنوان آرگومان ارسال کنند."

msgid "Example: a function that modifies fields of a struct using non-atomic writes. Two threads can each call the function on their own struct instance safely, but concurrent calls on the *same* instance require external synchronization."
msgstr "مثال: تابعی که فیلدهای یک ساختار را با استفاده از نوشتن‌های غیراتمی تغییر می‌دهد. دو نخ می‌توانند هر کدام تابع را روی نمونه‌ی ساختار خود به‌صورت ایمن فراخوانی کنند، اما فراخوانی‌های همزمان روی *همان* نمونه به همگام‌سازی خارجی نیاز دارند."

msgid "Safe on shared objects"
msgstr "ایمن روی اشیاء مشترک"

msgid "A function or operation that is safe for concurrent use on the **same** object. The implementation uses internal synchronization (such as :term:`per-object locks <per-object lock>` or :ref:`critical sections <python-critical-section-api>`) to protect shared mutable state, so callers do not need to supply their own locking."
msgstr "تابع یا عملیاتی که برای استفاده همزمان روی **همان** شیء ایمن است. پیاده‌سازی از همگام‌سازی داخلی (مانند :term:`قفل‌های به‌ازای هر شیء <per-object lock>` یا :ref:`بخش‌های بحرانی <python-critical-section-api>`) برای محافظت از وضعیت تغییرپذیر مشترک استفاده می‌کند، بنابراین فراخوان‌کنندگان نیازی به فراهم کردن قفل‌گذاری خودشان ندارند."

msgid "Example: :c:func:`PyList_GetItemRef` can be called from multiple threads on the same :c:type:`PyListObject` - it uses internal synchronization to serialize access."
msgstr "مثال: می‌توان :c:func:`PyList_GetItemRef` را از چندین نخ روی همان :c:type:`PyListObject` فراخوانی کرد - این تابع از همگام‌سازی داخلی برای متوالی‌کردن دسترسی استفاده می‌کند."

msgid "Atomic"
msgstr "اتمی"

msgid "A function or operation that appears :term:`atomic <atomic operation>` with respect to other threads - it executes instantaneously from the perspective of other threads. This is the strongest form of thread safety."
msgstr "تابع یا عملیاتی که نسبت به سایر نخ‌ها به‌صورت :term:`اتمی <atomic operation>` به نظر می‌رسد؛ از دید سایر نخ‌ها به‌صورت آنی اجرا می‌شود. این قوی‌ترین شکل ایمنی نخی است."

msgid "Example: :c:func:`PyMutex_IsLocked` performs an atomic read of the mutex state and can be called from any thread at any time."
msgstr "مثال: :c:func:`PyMutex_IsLocked` یک خواندن اتمی از وضعیت قفل متقابل (mutex) انجام می‌دهد و می‌تواند از هر نخی در هر زمانی فراخوانی شود."

msgid "Thread safety for list objects"
msgstr "ایمنی در برابر نخ‌ها برای اشیای فهرست"

msgid "Reading a single element from a :class:`list` is :term:`atomic <atomic operation>`:"
msgstr "خواندن یک عنصر از یک :class:`list` :term:`اتمی <atomic operation>` است:"

msgid "lst[i]   # list.__getitem__"
msgstr "lst[i]   # list.__getitem__"

msgid "The following methods traverse the list and use :term:`atomic <atomic operation>` reads of each item to perform their function. That means that they may return results affected by concurrent modifications:"
msgstr "متدهای زیر فهرست را پیمایش می‌کنند و از خواندن‌های :term:`اتمی <atomic operation>` هر آیتم برای انجام وظیفه خود استفاده می‌کنند. این بدان معناست که ممکن است نتایجی برگردانند که تحت تأثیر تغییرات همزمان قرار گرفته‌اند:"

msgid ""
"item in lst\n"
"lst.index(item)\n"
"lst.count(item)"
msgstr ""
"item in lst\n"
"lst.index(item)\n"
"lst.count(item)"

msgid "All of the above operations avoid acquiring :term:`per-object locks <per-object lock>`. They do not block concurrent modifications. Other operations that hold a lock will not block these from observing intermediate states."
msgstr "همه‌ی عملیات‌های بالا از کسب :term:`قفل‌های به‌ازای هر شیء <per-object lock>` خودداری می‌کنند. آن‌ها تغییرات همزمان را مسدود نمی‌کنند. سایر عملیات‌هایی که قفلی را در اختیار دارند، این عملیات‌ها را از مشاهده‌ی وضعیت‌های میانی باز نمی‌دارند."

msgid "All other operations from here on block using the :term:`per-object lock`."
msgstr "از این پس، همه‌ی عملیات‌های دیگر با استفاده از :term:`per-object lock` مسدود می‌شوند."

msgid "Writing a single item via ``lst[i] = x`` is safe to call from multiple threads and will not corrupt the list."
msgstr "نوشتن یک آیتم واحد از طریق ``lst[i] = x`` برای فراخوانی از چندین نخ ایمن است و فهرست را خراب نمی‌کند."

msgid "The following operations return new objects and appear :term:`atomic <atomic operation>` to other threads:"
msgstr "عملیات زیر اشیای جدیدی را برمی‌گردانند و برای نخ‌های دیگر :term:`اتمی <atomic operation>` به نظر می‌رسند:"

msgid ""
"lst1 + lst2    # concatenates two lists into a new list\n"
"x * lst        # repeats lst x times into a new list\n"
"lst.copy()     # returns a shallow copy of the list"
msgstr ""
"lst1 + lst2    # concatenates two lists into a new list\n"
"x * lst        # repeats lst x times into a new list\n"
"lst.copy()     # returns a shallow copy of the list"

msgid "The following methods that only operate on a single element with no shifting required are :term:`atomic <atomic operation>`:"
msgstr "متدهای زیر که تنها روی یک المان عمل می‌کنند و نیازی به جابه‌جایی ندارند، :term:`اتمی <atomic operation>` هستند:"

msgid ""
"lst.append(x)  # append to the end of the list, no shifting required\n"
"lst.pop()      # pop element from the end of the list, no shifting required"
msgstr ""
"lst.append(x)  # append to the end of the list, no shifting required\n"
"lst.pop()      # pop element from the end of the list, no shifting required"

msgid "The :meth:`~list.clear` method is also :term:`atomic <atomic operation>`. Other threads cannot observe elements being removed."
msgstr "متد :meth:`~list.clear` نیز :term:`اتمی <atomic operation>` است. سایر نخ‌ها نمی‌توانند حذف شدن عناصر را مشاهده کنند."

msgid "The :meth:`~list.sort` method is not :term:`atomic <atomic operation>`. Other threads cannot observe intermediate states during sorting, but the list appears empty for the duration of the sort."
msgstr "متد :meth:`~list.sort` :term:`اتمی <atomic operation>` نیست. سایر نخ‌ها نمی‌توانند وضعیت‌های میانی را در حین مرتب‌سازی مشاهده کنند، اما فهرست در طول مدت مرتب‌سازی خالی به نظر می‌رسد."

msgid "The following operations may allow :term:`lock-free` operations to observe intermediate states since they modify multiple elements in place:"
msgstr "عملیات‌های زیر ممکن است به عملیات :term:`lock-free` اجازه دهند که وضعیت‌های میانی را مشاهده کنند، زیرا چندین المان را به‌صورت درجا تغییر می‌دهند:"

msgid ""
"lst.insert(idx, item)  # shifts elements\n"
"lst.pop(idx)           # idx not at the end of the list, shifts elements\n"
"lst *= x               # copies elements in place"
msgstr ""
"lst.insert(idx, item)  # shifts elements\n"
"lst.pop(idx)           # idx not at the end of the list, shifts elements\n"
"lst *= x               # copies elements in place"

msgid "The :meth:`~list.remove` method may allow concurrent modifications since element comparison may execute arbitrary Python code (via :meth:`~object.__eq__`)."
msgstr "متد :meth:`~list.remove` ممکن است اجازه‌ی تغییرات همزمان را بدهد، زیرا مقایسه‌ی عنصر ممکن است کد پایتون دلخواه را اجرا کند (از طریق :meth:`~object.__eq__`)."

msgid ":meth:`~list.extend` is safe to call from multiple threads.  However, its guarantees depend on the iterable passed to it. If it is a :class:`list`, a :class:`tuple`, a :class:`set`, a :class:`frozenset`, a :class:`dict` or a :ref:`dictionary view object <dict-views>` (but not their subclasses), the ``extend`` operation is safe from concurrent modifications to the iterable. Otherwise, an iterator is created which can be concurrently modified by another thread.  The same applies to inplace concatenation of a list with other iterables when using ``lst += iterable``."
msgstr "فراخوانی :meth:`~list.extend` از چندین نخ ایمن است. با این حال، تضمین‌های آن به پیمایش‌پذیری که به آن داده می‌شود بستگی دارد. اگر این پیمایش‌پذیر یک :class:`list`، :class:`tuple`، :class:`set`، :class:`frozenset`، :class:`dict` یا :ref:`شیء نمای دیکشنری <dict-views>` باشد (اما نه زیرکلاس‌های آن‌ها)، عملیات ``extend`` در برابر تغییرات همزمان روی پیمایش‌پذیر ایمن است. در غیر این صورت، یک پیمایش‌گر ایجاد می‌شود که ممکن است توسط نخ دیگری به‌طور همزمان تغییر داده شود. همین موضوع برای الحاق درجای یک فهرست با سایر پیمایش‌پذیرها هنگام استفاده از ``lst += iterable`` نیز صدق می‌کند."

msgid "Similarly, assigning to a list slice with ``lst[i:j] = iterable`` is safe to call from multiple threads, but ``iterable`` is only locked when it is also a :class:`list` (but not its subclasses)."
msgstr "به‌طور مشابه، انتساب به یک اسلایس فهرست با ``lst[i:j] = iterable`` برای فراخوانی از چندین نخ امن است، اما ``iterable`` تنها زمانی قفل می‌شود که خود نیز یک :class:`list` باشد (اما نه زیرکلاس‌های آن)."

msgid "Operations that involve multiple accesses, as well as iteration, are never atomic. For example:"
msgstr "عملیات‌هایی که شامل چندین دسترسی و همچنین تکرار هستند، هرگز اتمی نیستند. برای مثال:"

msgid ""
"# NOT atomic: read-modify-write\n"
"lst[i] = lst[i] + 1\n"
"\n"
"# NOT atomic: check-then-act\n"
"if lst:\n"
"    item = lst.pop()\n"
"\n"
"# NOT thread-safe: iteration while modifying\n"
"for item in lst:\n"
"    process(item)  # another thread may modify lst"
msgstr ""
"# NOT atomic: read-modify-write\n"
"lst[i] = lst[i] + 1\n"
"\n"
"# NOT atomic: check-then-act\n"
"if lst:\n"
"    item = lst.pop()\n"
"\n"
"# NOT thread-safe: iteration while modifying\n"
"for item in lst:\n"
"    process(item)  # another thread may modify lst"

msgid "Consider external synchronization when sharing :class:`list` instances across threads."
msgstr "هنگام اشتراک‌گذاری نمونه‌های :class:`list` میان نخ‌ها، همگام‌سازی خارجی را در نظر بگیرید."

msgid "Thread safety for dict objects"
msgstr "ایمنی نخی برای اشیاء دیکشنری"

msgid "Creating a dictionary with the :class:`dict` constructor is atomic when the argument to it is a :class:`dict` or a :class:`tuple`. When using the :meth:`dict.fromkeys` method, dictionary creation is atomic when the argument is a :class:`dict`, :class:`tuple`, :class:`set` or :class:`frozenset`."
msgstr "ایجاد یک دیکشنری با سازنده‌ی :class:`dict` زمانی اتمی است که آرگومان آن یک :class:`dict` یا یک :class:`tuple` باشد. هنگام استفاده از متد :meth:`dict.fromkeys`، ایجاد دیکشنری زمانی اتمی است که آرگومان یک :class:`dict`، :class:`tuple`، :class:`set` یا :class:`frozenset` باشد."

msgid "The following operations and functions are :term:`lock-free` and :term:`atomic <atomic operation>`."
msgstr "عملیات و توابع زیر :term:`بدون قفل <lock-free>` و :term:`اتمی <atomic operation>` هستند."

msgid ""
"d[key]       # dict.__getitem__\n"
"d.get(key)   # dict.get\n"
"key in d     # dict.__contains__\n"
"len(d)       # dict.__len__"
msgstr ""
"d[key]       # dict.__getitem__\n"
"d.get(key)   # dict.get\n"
"key in d     # dict.__contains__\n"
"len(d)       # dict.__len__"

msgid "All other operations from here on hold the :term:`per-object lock`."
msgstr "تمام عملیات‌های دیگر از اینجا به بعد، :term:`per-object lock` را در اختیار دارند."

msgid "Writing or removing a single item is safe to call from multiple threads and will not corrupt the dictionary:"
msgstr "نوشتن یا حذف یک آیتم واحد برای فراخوانی از چندین نخ ایمن است و دیکشنری را خراب نمی‌کند:"

msgid ""
"d[key] = value        # write\n"
"del d[key]            # delete\n"
"d.pop(key)            # remove and return\n"
"d.popitem()           # remove and return last item\n"
"d.setdefault(key, v)  # insert if missing"
msgstr ""
"d[key] = value        # write\n"
"del d[key]            # delete\n"
"d.pop(key)            # remove and return\n"
"d.popitem()           # remove and return last item\n"
"d.setdefault(key, v)  # insert if missing"

msgid "These operations may compare keys using :meth:`~object.__eq__`, which can execute arbitrary Python code. During such comparisons, the dictionary may be modified by another thread. For built-in types like :class:`str`, :class:`int`, and :class:`float`, that implement :meth:`~object.__eq__` in C, the underlying lock is not released during comparisons and this is not a concern."
msgstr "این عملیات‌ها ممکن است کلیدها را با استفاده از :meth:`~object.__eq__` مقایسه کنند، که می‌تواند کد پایتون دلخواه را اجرا کند. در حین چنین مقایسه‌هایی، ممکن است دیکشنری توسط نخ دیگری تغییر داده شود. برای انواع توکار مانند :class:`str`، :class:`int` و :class:`float`، که :meth:`~object.__eq__` را در C پیاده‌سازی می‌کنند، قفل زیربنایی در حین مقایسه‌ها آزاد نمی‌شود و این موضوع جای نگرانی نیست."

msgid "The following operations return new objects and hold the :term:`per-object lock` for the duration of the operation:"
msgstr "عملیات‌های زیر شیءهای جدید را برمی‌گردانند و در طول مدت عملیات، :term:`per-object lock` را نگه می‌دارند:"

msgid ""
"d.copy()      # returns a shallow copy of the dictionary\n"
"d | other     # merges two dicts into a new dict\n"
"d.keys()      # returns a new dict_keys view object\n"
"d.values()    # returns a new dict_values view object\n"
"d.items()     # returns a new dict_items view object"
msgstr ""
"d.copy()      # returns a shallow copy of the dictionary\n"
"d | other     # merges two dicts into a new dict\n"
"d.keys()      # returns a new dict_keys view object\n"
"d.values()    # returns a new dict_values view object\n"
"d.items()     # returns a new dict_items view object"

msgid "The :meth:`~dict.clear` method holds the lock for its duration. Other threads cannot observe elements being removed."
msgstr "متد :meth:`~dict.clear` قفل را در طول مدت اجرای خود نگه می‌دارد. نخ‌های دیگر نمی‌توانند حذف عناصر را مشاهده کنند."

msgid "The following operations lock both dictionaries. For :meth:`~dict.update` and ``|=``, this applies only when the other operand is a :class:`dict` that uses the standard dict iterator (but not subclasses that override iteration). For equality comparison, this applies to :class:`dict` and its subclasses:"
msgstr "عملیات زیر هر دو دیکشنری را قفل می‌کنند. برای :meth:`~dict.update` و ``|=``، این موضوع فقط زمانی صدق می‌کند که عملوند دیگر یک :class:`dict` باشد که از پیمایش‌گر استاندارد دیکشنری استفاده می‌کند (اما نه زیرکلاس‌هایی که پیمایش را بازنویسی می‌کنند). در مقایسه برابری، این موضوع برای :class:`dict` و زیرکلاس‌های آن صدق می‌کند:"

msgid ""
"d.update(other_dict)  # both locked when other_dict is a dict\n"
"d |= other_dict       # both locked when other_dict is a dict\n"
"d == other_dict       # both locked for dict and subclasses"
msgstr ""
"d.update(other_dict)  # both locked when other_dict is a dict\n"
"d |= other_dict       # both locked when other_dict is a dict\n"
"d == other_dict       # both locked for dict and subclasses"

msgid "All comparison operations also compare values using :meth:`~object.__eq__`, so for non-built-in types the lock may be released during comparison."
msgstr "تمام عملیات‌های مقایسه نیز مقادیر را با استفاده از :meth:`~object.__eq__` مقایسه می‌کنند، بنابراین برای انواع غیرتوکار ممکن است قفل در حین مقایسه آزاد شود."

msgid ":meth:`~dict.fromkeys` locks both the new dictionary and the iterable when the iterable is exactly a :class:`dict`, :class:`set`, or :class:`frozenset` (not subclasses):"
msgstr ":meth:`~dict.fromkeys` هر دو دیکشنری جدید و پیمایش‌پذیر را زمانی که پیمایش‌پذیر دقیقاً یک :class:`dict`، :class:`set` یا :class:`frozenset` باشد (نه زیرکلاس‌ها) قفل می‌کند:"

msgid ""
"dict.fromkeys(a_dict)      # locks both\n"
"dict.fromkeys(a_set)       # locks both\n"
"dict.fromkeys(a_frozenset) # locks both"
msgstr ""
"dict.fromkeys(a_dict)      # locks both\n"
"dict.fromkeys(a_set)       # locks both\n"
"dict.fromkeys(a_frozenset) # locks both"

msgid "When updating from a non-dict iterable, only the target dictionary is locked. The iterable may be concurrently modified by another thread:"
msgstr "هنگام به‌روزرسانی از یک پیمایش‌پذیر غیر از دیکشنری، فقط دیکشنری هدف قفل می‌شود. ممکن است پیمایش‌پذیر به‌طور همزمان توسط نخ دیگری تغییر داده شود:"

msgid ""
"d.update(iterable)        # iterable is not a dict: only d locked\n"
"d |= iterable             # iterable is not a dict: only d locked\n"
"dict.fromkeys(iterable)   # iterable is not a dict/set/frozenset: only result locked"
msgstr ""
"d.update(iterable)        # iterable is not a dict: only d locked\n"
"d |= iterable             # iterable is not a dict: only d locked\n"
"dict.fromkeys(iterable)   # iterable is not a dict/set/frozenset: only result locked"

msgid "Operations that involve multiple accesses, as well as iteration, are never atomic:"
msgstr "عملیات‌هایی که شامل چندین دسترسی هستند، و همچنین پیمایش، هرگز اتمی نیستند:"

msgid ""
"# NOT atomic: read-modify-write\n"
"d[key] = d[key] + 1\n"
"\n"
"# NOT atomic: check-then-act (TOCTOU)\n"
"if key in d:\n"
"    del d[key]\n"
"\n"
"# NOT thread-safe: iteration while modifying\n"
"for key, value in d.items():\n"
"    process(key)  # another thread may modify d"
msgstr ""
"# NOT atomic: read-modify-write\n"
"d[key] = d[key] + 1\n"
"\n"
"# NOT atomic: check-then-act (TOCTOU)\n"
"if key in d:\n"
"    del d[key]\n"
"\n"
"# NOT thread-safe: iteration while modifying\n"
"for key, value in d.items():\n"
"    process(key)  # another thread may modify d"

msgid "To avoid time-of-check to time-of-use (TOCTOU) issues, use atomic operations or handle exceptions:"
msgstr "برای جلوگیری از مشکلات زمان بررسی تا زمان استفاده (TOCTOU)، از عملیات اتمی استفاده کنید یا استثناها را مدیریت کنید:"

msgid ""
"# Use pop() with default instead of check-then-delete\n"
"d.pop(key, None)\n"
"\n"
"# Or handle the exception\n"
"try:\n"
"    del d[key]\n"
"except KeyError:\n"
"    pass"
msgstr ""
"# Use pop() with default instead of check-then-delete\n"
"d.pop(key, None)\n"
"\n"
"# Or handle the exception\n"
"try:\n"
"    del d[key]\n"
"except KeyError:\n"
"    pass"

msgid "To safely iterate over a dictionary that may be modified by another thread, iterate over a copy:"
msgstr "برای پیمایش ایمن روی دیکشنری‌ای که ممکن است توسط نخ دیگری تغییر داده شود، روی یک نسخه از آن پیمایش کنید:"

msgid ""
"# Make a copy to iterate safely\n"
"for key, value in d.copy().items():\n"
"    process(key)"
msgstr ""
"# Make a copy to iterate safely\n"
"for key, value in d.copy().items():\n"
"    process(key)"

msgid "Consider external synchronization when sharing :class:`dict` instances across threads."
msgstr "هنگام اشتراک‌گذاری نمونه‌های :class:`dict` میان نخ‌ها، همگام‌سازی خارجی را در نظر بگیرید."

msgid "Thread safety for set objects"
msgstr "ایمنی نخی برای اشیای مجموعه"

msgid "The :func:`len` function is lock-free and :term:`atomic <atomic operation>`."
msgstr "تابع :func:`len` بدون قفل و :term:`اتمی <atomic operation>` است."

msgid "The following read operation is lock-free. It does not block concurrent modifications and may observe intermediate states from operations that hold the per-object lock:"
msgstr "عملیات خواندن زیر بدون قفل است. این عملیات تغییرات همزمان را مسدود نمی‌کند و ممکن است وضعیت‌های میانیِ عملیاتی را که قفل به‌ازای هر شیء را در اختیار دارند، مشاهده کند:"

msgid "elem in s    # set.__contains__"
msgstr "elem in s    # set.__contains__"

msgid "This operation may compare elements using :meth:`~object.__eq__`, which can execute arbitrary Python code. During such comparisons, the set may be modified by another thread. For built-in types like :class:`str`, :class:`int`, and :class:`float`, :meth:`!__eq__` does not release the underlying lock during comparisons and this is not a concern."
msgstr "این عملیات ممکن است عناصر را با استفاده از :meth:`~object.__eq__`، که می‌تواند کد پایتون دلخواه را اجرا کند، مقایسه کند. در طول چنین مقایسه‌هایی، ممکن است مجموعه توسط نخ دیگری تغییر کند. برای انواع توکار مانند :class:`str`، :class:`int` و :class:`float`، :meth:`!__eq__` قفل زیرین را در طول مقایسه‌ها آزاد نمی‌کند و این جای نگرانی نیست."

msgid "All other operations from here on hold the per-object lock."
msgstr "از این نقطه به بعد، تمام عملیات‌های دیگر قفل به‌ازای هر شیء را نگه می‌دارند."

msgid "Adding or removing a single element is safe to call from multiple threads and will not corrupt the set:"
msgstr "افزودن یا حذف یک المان منفرد را می‌توان به‌صورت امن از چند نخ فراخوانی کرد و مجموعه خراب نمی‌شود:"

msgid ""
"s.add(elem)      # add element\n"
"s.remove(elem)   # remove element, raise if missing\n"
"s.discard(elem)  # remove element if present\n"
"s.pop()          # remove and return arbitrary element"
msgstr ""
"s.add(elem)      # add element\n"
"s.remove(elem)   # remove element, raise if missing\n"
"s.discard(elem)  # remove element if present\n"
"s.pop()          # remove and return arbitrary element"

msgid "These operations also compare elements, so the same :meth:`~object.__eq__` considerations as above apply."
msgstr "این عملیات‌ها همچنین عناصر را مقایسه می‌کنند، بنابراین همان ملاحظات :meth:`~object.__eq__` بالا اعمال می‌شوند."

msgid "The :meth:`~set.copy` method returns a new object and holds the per-object lock for the duration so that it is always atomic."
msgstr "متد :meth:`~set.copy` یک شیء جدید بازمی‌گرداند و قفل به‌ازای هر شیء را در طول این مدت نگه می‌دارد تا همیشه اتمی باشد."

msgid "The :meth:`~set.clear` method holds the lock for its duration. Other threads cannot observe elements being removed."
msgstr "متد :meth:`~set.clear` قفل را در طول مدت اجرای خود نگه می‌دارد. سایر نخ‌ها نمی‌توانند عناصر در حال حذف را مشاهده کنند."

msgid "The following operations only accept :class:`set` or :class:`frozenset` as operands and always lock both objects:"
msgstr "عملیات‌های زیر فقط :class:`set` یا :class:`frozenset` را به‌عنوان عملوند می‌پذیرند و همیشه هر دو شیء را قفل می‌کنند:"

msgid ""
"s |= other                   # other must be set/frozenset\n"
"s &= other                   # other must be set/frozenset\n"
"s -= other                   # other must be set/frozenset\n"
"s ^= other                   # other must be set/frozenset\n"
"s & other                    # other must be set/frozenset\n"
"s | other                    # other must be set/frozenset\n"
"s - other                    # other must be set/frozenset\n"
"s ^ other                    # other must be set/frozenset"
msgstr ""
"s |= other                   # other must be set/frozenset\n"
"s &= other                   # other must be set/frozenset\n"
"s -= other                   # other must be set/frozenset\n"
"s ^= other                   # other must be set/frozenset\n"
"s & other                    # other must be set/frozenset\n"
"s | other                    # other must be set/frozenset\n"
"s - other                    # other must be set/frozenset\n"
"s ^ other                    # other must be set/frozenset"

msgid ":meth:`set.update`, :meth:`set.union`, :meth:`set.intersection` and :meth:`set.difference` can take multiple iterables as arguments. They all iterate through all the passed iterables and do the following:"
msgstr ":meth:`set.update`، :meth:`set.union`، :meth:`set.intersection` و :meth:`set.difference` می‌توانند چندین پیمایش‌پذیر را به‌عنوان آرگومان بگیرند. همه‌ی آن‌ها تمام پیمایش‌پذیرهای داده‌شده را پیمایش می‌کنند و کار زیر را انجام می‌دهند:"

msgid ":meth:`set.update` and :meth:`set.union` lock both objects only when"
msgstr ":meth:`set.update` و :meth:`set.union` هر دو شیء را فقط زمانی قفل می‌کنند که"

msgid "the other operand is a :class:`set`, :class:`frozenset`, or :class:`dict`."
msgstr "عملوند دیگر یک :class:`set`، :class:`frozenset` یا :class:`dict` است."

msgid ":meth:`set.intersection` and :meth:`set.difference` always try to lock"
msgstr ":meth:`set.intersection` و :meth:`set.difference` همیشه سعی می‌کنند قفل کنند"

msgid "all objects."
msgstr "تمام اشیاء."

msgid ":meth:`set.symmetric_difference` tries to lock both objects."
msgstr ":meth:`set.symmetric_difference` تلاش می‌کند هر دو شیء را قفل کند."

msgid "The update variants of the above methods also have some differences between them:"
msgstr "گونه‌های به‌روزرسانی متدهای بالا نیز تفاوت‌هایی با یکدیگر دارند:"

msgid ":meth:`set.difference_update` and :meth:`set.intersection_update` try"
msgstr ":meth:`set.difference_update` و :meth:`set.intersection_update` تلاش می‌کنند"

msgid "to lock all objects one-by-one."
msgstr "برای قفل کردن همه‌ی اشیاء به‌صورت یکی‌یکی."

msgid ":meth:`set.symmetric_difference_update` only locks the arguments if it is"
msgstr ":meth:`set.symmetric_difference_update` آرگومان‌ها را تنها در صورتی قفل می‌کند که"

msgid "of type :class:`set`, :class:`frozenset`, or :class:`dict`."
msgstr "از نوع :class:`set`، :class:`frozenset` یا :class:`dict`."

msgid "The following methods always try to lock both objects:"
msgstr "متدهای زیر همیشه تلاش می‌کنند هر دو شیء را قفل کنند:"

msgid ""
"s.isdisjoint(other)          # both locked\n"
"s.issubset(other)            # both locked\n"
"s.issuperset(other)          # both locked"
msgstr ""
"s.isdisjoint(other)          # both locked\n"
"s.issubset(other)            # both locked\n"
"s.issuperset(other)          # both locked"

msgid ""
"# NOT atomic: check-then-act\n"
"if elem in s:\n"
"      s.remove(elem)\n"
"\n"
"# NOT thread-safe: iteration while modifying\n"
"for elem in s:\n"
"      process(elem)  # another thread may modify s"
msgstr ""
"# NOT atomic: check-then-act\n"
"if elem in s:\n"
"      s.remove(elem)\n"
"\n"
"# NOT thread-safe: iteration while modifying\n"
"for elem in s:\n"
"      process(elem)  # another thread may modify s"

msgid "Consider external synchronization when sharing :class:`set` instances across threads.  See :ref:`freethreading-python-howto` for more information."
msgstr "هنگام اشتراک‌گذاری نمونه‌های :class:`set` بین نخ‌ها، همگام‌سازی خارجی را در نظر بگیرید. برای اطلاعات بیشتر :ref:`freethreading-python-howto` را ببینید."

msgid "Thread safety for bytearray objects"
msgstr "ایمنی نخی برای اشیاء bytearray"

msgid "Concatenation and comparisons use the buffer protocol, which prevents resizing but does not hold the per-object lock. These operations may observe intermediate states from concurrent modifications:"
msgstr "الحاق و مقایسه‌ها از پروتکل بافر استفاده می‌کنند، که از تغییر اندازه جلوگیری می‌کند اما قفل به‌ازای هر شیء را نگه نمی‌دارد. این عملیات ممکن است وضعیت‌های میانی ناشی از تغییرات همزمان را مشاهده کنند:"

msgid ""
"ba + other    # may observe concurrent writes\n"
"ba == other   # may observe concurrent writes\n"
"ba < other    # may observe concurrent writes"
msgstr ""
"ba + other    # may observe concurrent writes\n"
"ba == other   # may observe concurrent writes\n"
"ba < other    # may observe concurrent writes"

msgid "Reading a single element or slice is safe to call from multiple threads:"
msgstr "خواندن یک عنصر یا اسلایس برای فراخوانی از چندین نخ امن است:"

msgid ""
"ba[i]        # bytearray.__getitem__\n"
"ba[i:j]      # slice"
msgstr ""
"ba[i]        # bytearray.__getitem__\n"
"ba[i:j]      # slice"

msgid "The following operations are safe to call from multiple threads and will not corrupt the bytearray:"
msgstr "فراخوانی عملیات زیر از چندین نخ ایمن است و bytearray را خراب نمی‌کند:"

msgid ""
"ba[i] = x         # write single byte\n"
"ba[i:j] = values  # write slice\n"
"ba.append(x)      # append single byte\n"
"ba.extend(other)  # extend with iterable\n"
"ba.insert(i, x)   # insert single byte\n"
"ba.pop()          # remove and return last byte\n"
"ba.pop(i)         # remove and return byte at index\n"
"ba.remove(x)      # remove first occurrence\n"
"ba.reverse()      # reverse in place\n"
"ba.clear()        # remove all bytes"
msgstr ""
"ba[i] = x         # write single byte\n"
"ba[i:j] = values  # write slice\n"
"ba.append(x)      # append single byte\n"
"ba.extend(other)  # extend with iterable\n"
"ba.insert(i, x)   # insert single byte\n"
"ba.pop()          # remove and return last byte\n"
"ba.pop(i)         # remove and return byte at index\n"
"ba.remove(x)      # remove first occurrence\n"
"ba.reverse()      # reverse in place\n"
"ba.clear()        # remove all bytes"

msgid "Slice assignment locks both objects when *values* is a :class:`bytearray`:"
msgstr "انتساب اسلایسی هنگامی که *values* یک :class:`bytearray` باشد، هر دو شیء را قفل می‌کند:"

msgid "ba[i:j] = other_bytearray  # both locked"
msgstr "ba[i:j] = other_bytearray  # هر دو قفل هستند"

msgid "The following operations return new objects and hold the per-object lock for the duration:"
msgstr "عملیات زیر اشیای جدید را برمی‌گردانند و قفل به‌ازای هر شیء را در طول مدت آن نگه می‌دارند:"

msgid ""
"ba.copy()     # returns a shallow copy\n"
"ba * n        # repeat into new bytearray"
msgstr ""
"ba.copy()     # returns a shallow copy\n"
"ba * n        # repeat into new bytearray"

msgid "The membership test holds the lock for its duration:"
msgstr "آزمون عضویت، قفل را در طول مدت خود نگه می‌دارد:"

msgid "x in ba       # bytearray.__contains__"
msgstr "x in ba       # bytearray.__contains__"

msgid "All other bytearray methods (such as :meth:`~bytearray.find`, :meth:`~bytearray.replace`, :meth:`~bytearray.split`, :meth:`~bytearray.decode`, etc.) hold the per-object lock for their duration."
msgstr "تمام متدهای دیگر bytearray (مانند :meth:`~bytearray.find`، :meth:`~bytearray.replace`، :meth:`~bytearray.split`، :meth:`~bytearray.decode` و غیره) در طول اجرای خود، قفل به‌ازای هر شیء را نگه می‌دارند."

msgid ""
"# NOT atomic: check-then-act\n"
"if x in ba:\n"
"    ba.remove(x)\n"
"\n"
"# NOT thread-safe: iteration while modifying\n"
"for byte in ba:\n"
"    process(byte)  # another thread may modify ba"
msgstr ""
"# NOT atomic: check-then-act\n"
"if x in ba:\n"
"    ba.remove(x)\n"
"\n"
"# NOT thread-safe: iteration while modifying\n"
"for byte in ba:\n"
"    process(byte)  # another thread may modify ba"

msgid "To safely iterate over a bytearray that may be modified by another thread, iterate over a copy:"
msgstr "برای پیمایش امن روی bytearray که ممکن است توسط نخ دیگری تغییر کند، روی یک کپی پیمایش کنید:"

msgid ""
"# Make a copy to iterate safely\n"
"for byte in ba.copy():\n"
"    process(byte)"
msgstr ""
"# Make a copy to iterate safely\n"
"for byte in ba.copy():\n"
"    process(byte)"

msgid "Consider external synchronization when sharing :class:`bytearray` instances across threads.  See :ref:`freethreading-python-howto` for more information."
msgstr "هنگام اشتراک‌گذاری نمونه‌های :class:`bytearray` بین نخ‌ها، همگام‌سازی خارجی را در نظر بگیرید. برای اطلاعات بیشتر :ref:`freethreading-python-howto` را ببینید."

msgid "Thread safety for memoryview objects"
msgstr "ایمنی نخ برای اشیای memoryview"

msgid ":class:`memoryview` objects provide access to the internal data of an underlying object without copying. Thread safety depends on both the memoryview itself and the underlying buffer exporter."
msgstr "اشیای :class:`memoryview` دسترسی به داده‌های داخلی یک شیء زیربنایی را بدون کپی کردن فراهم می‌کنند. ایمنی نخی هم به خود memoryview و هم به اکسپورتکننده‌ی بافر زیربنایی بستگی دارد."

msgid "The memoryview implementation uses atomic operations to track its own exports in the :term:`free-threaded build`. Creating and releasing a memoryview are thread-safe. Attribute access (e.g., :attr:`~memoryview.shape`, :attr:`~memoryview.format`) reads fields that are immutable for the lifetime of the memoryview, so concurrent reads are safe as long as the memoryview has not been released."
msgstr "پیاده‌سازی memoryview از عملیات اتمی برای پیگیری اکسپورت‌های خود در :term:`free-threaded build` استفاده می‌کند. ایجاد و آزادسازی یک memoryview نخ‌ایمن (thread-safe) هستند. دسترسی به ویژگی‌ها (برای مثال، :attr:`~memoryview.shape`، :attr:`~memoryview.format`) فیلدهایی را می‌خواند که در طول عمر memoryview تغییرناپذیر هستند، بنابراین خواندن‌های همزمان تا زمانی که memoryview آزاد نشده باشد، ایمن هستند."

msgid "However, the actual data accessed through the memoryview is owned by the underlying object. Concurrent access to this data is only safe if the underlying object supports it:"
msgstr "با این حال، داده‌ی واقعی که از طریق memoryview به آن دسترسی دارید، متعلق به شیء زیربنایی است. دسترسی همزمان به این داده تنها در صورتی امن است که شیء زیربنایی از آن پشتیبانی کند:"

msgid "For immutable objects like :class:`bytes`, concurrent reads through multiple memoryviews are safe."
msgstr "برای اشیاء تغییرناپذیر مانند :class:`bytes`، خواندن‌های همزمان از طریق چندین نمای حافظه (memoryview) ایمن هستند."

msgid "For mutable objects like :class:`bytearray`, reading and writing the same memory region from multiple threads without external synchronization is not safe and may result in data corruption. Note that even read-only memoryviews of mutable objects do not prevent data races if the underlying object is modified from another thread."
msgstr "برای اشیاء تغییرپذیر مانند :class:`bytearray`، خواندن و نوشتن یک ناحیه‌ی حافظه‌ی یکسان توسط چند نخ بدون همگام‌سازی خارجی ایمن نیست و ممکن است به خرابی داده منجر شود. توجه داشته باشید که حتی memoryviewهای فقط‌خواندنی از اشیاء تغییرپذیر نیز در صورتی که شیء زیرین توسط نخ دیگری تغییر کند، از رقابت‌های داده‌ای جلوگیری نمی‌کنند."

msgid ""
"# NOT safe: concurrent writes to the same buffer\n"
"data = bytearray(1000)\n"
"view = memoryview(data)\n"
"# Thread 1: view[0:500] = b'x' * 500\n"
"# Thread 2: view[0:500] = b'y' * 500"
msgstr ""
"# NOT safe: concurrent writes to the same buffer\n"
"data = bytearray(1000)\n"
"view = memoryview(data)\n"
"# Thread 1: view[0:500] = b'x' * 500\n"
"# Thread 2: view[0:500] = b'y' * 500"

msgid ""
"# Safe: use a lock for concurrent access\n"
"import threading\n"
"lock = threading.Lock()\n"
"data = bytearray(1000)\n"
"view = memoryview(data)\n"
"\n"
"with lock:\n"
"    view[0:500] = b'x' * 500"
msgstr ""
"# Safe: use a lock for concurrent access\n"
"import threading\n"
"lock = threading.Lock()\n"
"data = bytearray(1000)\n"
"view = memoryview(data)\n"
"\n"
"with lock:\n"
"    view[0:500] = b'x' * 500"

msgid "Resizing or reallocating the underlying object (such as calling :meth:`bytearray.resize`) while a memoryview is exported raises :exc:`BufferError`. This is enforced regardless of threading."
msgstr "تغییر اندازه یا تخصیص مجدد شیء زیرین (مانند فراخوانی :meth:`bytearray.resize`) در حالی که یک memoryview اکسپورت شده باشد، :exc:`BufferError` را پرتاب می‌کند. این امر صرف‌نظر از نخ‌بندی اعمال می‌شود."