# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , YEAR.
#
# Translators:
# Rafael Fontenelle , 2026
# python-doc bot, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-08-11 14:51+0000\n"
"PO-Revision-Date: 2026-02-25 14:46+0000\n"
"Last-Translator: python-doc bot, 2026\n"
"Language-Team: Polish (https://app.transifex.com/python-doc/teams/5390/pl/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: pl\n"
"Plural-Forms: nplurals=4; plural=(n==1 ? 0 : (n%10>=2 && n%10=0 && n%10=5 && "
"n%10=12 && n%100guard;\n"
"\n"
"// Create a new thread state for the interpreter.\n"
"PyThreadStateToken *token = PyThreadState_Ensure(guard);\n"
"if (token == NULL) {\n"
"   PyInterpreterGuard_Close(guard);\n"
"   return;\n"
"}\n"
"\n"
"// We have a valid thread state -- perform Python actions here.\n"
"result = CallSomeFunction();\n"
"// Evaluate result or handle exceptions.\n"
"\n"
"// Release the thread state. No calls to the C API are allowed beyond this\n"
"// point.\n"
"PyThreadState_Release(token);\n"
"PyInterpreterGuard_Close(guard);"
msgstr ""

msgid ""
"Keep in mind that calling ``PyThreadState_Ensure`` might not always create a "
"new thread state, and calling ``PyThreadState_Release`` might not always "
"detach it. These functions may reuse an existing attached thread state, or "
"may re-attach a thread state that was previously attached for the current "
"thread."
msgstr ""

msgid ":pep:`788`"
msgstr ""

msgid "Reusing a thread state across repeated calls"
msgstr ""

msgid ""
"Creating and destroying a :c:type:`PyThreadState` is not free, and is more "
"expensive on a :term:`free-threaded build`.  A foreign thread that calls "
"into the interpreter many times -- for example, a worker thread in a native "
"thread pool -- should avoid creating a fresh thread state on every entry and "
"destroying it on every exit.  Instead, set up one thread state when the "
"thread starts (or lazily on its first call into Python), attach and detach "
"it around each call, and tear it down once when the thread exits."
msgstr ""

msgid ""
"Manage the thread state explicitly with :c:func:`PyThreadState_New`, "
"attaching and detaching it with :c:func:`PyEval_RestoreThread` and :c:func:"
"`PyEval_SaveThread`.  This happens in three distinct phases, at different "
"points in the thread's life."
msgstr ""

msgid ""
"When the thread starts, create one thread state for it.  ``interp`` is the "
"target interpreter, captured by the code that created this thread while it "
"held an attached thread state (for example via :c:func:"
"`PyInterpreterState_Get`)::"
msgstr ""

msgid "PyThreadState *tstate = PyThreadState_New(interp);"
msgstr ""

msgid ""
"Then, on each call into Python -- which may happen many times over the "
"thread's life -- attach the thread state, make the Python C API calls that "
"require it, and detach again so the thread does not hold the GIL while off "
"doing non-Python work::"
msgstr ""

msgid ""
"PyEval_RestoreThread(tstate);\n"
"result = CallSomeFunction();  /* your Python C API calls go here */\n"
"PyEval_SaveThread();"
msgstr ""

msgid ""
"When the thread is finished calling into Python, destroy the thread state "
"once::"
msgstr ""

msgid ""
"PyEval_RestoreThread(tstate);\n"
"PyThreadState_Clear(tstate);\n"
"PyThreadState_DeleteCurrent();"
msgstr ""

msgid ""
"The general-purpose entry points for calling in from a foreign thread -- :c:"
"func:`PyThreadState_Ensure` and the older :c:func:`PyGILState_Ensure` -- do "
"*not* guarantee a persistent thread state: their thread-state lifetime is "
"deliberately implementation-defined, so a matched acquire/release pair may "
"create and destroy a thread state each time.  Use :c:func:"
"`PyThreadState_New`, as shown here, whenever you specifically want to reuse "
"one thread state across calls."
msgstr ""

msgid ""
"The code that created the foreign thread must arrange for the shutdown "
"sequence to run before the thread exits, and before :c:func:`Py_FinalizeEx` "
"is called. If interpreter finalization begins first, the shutdown :c:func:"
"`PyEval_RestoreThread` call will hang the thread rather than return (see :"
"ref:`cautions-regarding-runtime-finalization`).  If the thread exits without "
"running the shutdown sequence, the thread state is leaked for the remainder "
"of the process."
msgstr ""

msgid "Attaching/detaching thread states"
msgstr ""

msgid ""
"Ensure that the thread has an attached thread state for the interpreter "
"protected by *guard*, and thus can safely invoke that interpreter."
msgstr ""

msgid ""
"It is OK to call this function if the thread already has an attached thread "
"state, as long as there is a subsequent call to :c:func:"
"`PyThreadState_Release` that matches this one (meaning that \"nested\" calls "
"to this function are permitted)."
msgstr ""

msgid ""
"The function's effect (if any) will be reversed by the matching call to :c:"
"func:`PyThreadState_Release`."
msgstr ""

msgid ""
"On error, this function returns ``NULL`` *without* an exception set. Do not "
"call :c:func:`!PyThreadState_Release` in this case."
msgstr ""

msgid ""
"On success, this function returns a pointer value that must be passed to the "
"matching call to :c:func:`!PyThreadState_Release`."
msgstr ""

msgid ""
"The conditions in which this function creates a new :term:`thread state` are "
"considered unstable and implementation-dependent. If you need to control the "
"exact lifetime of a thread state, consider using :c:func:"
"`PyThreadState_New`. However, do not avoid this function solely on the basis "
"that the lifetime of the thread state may be inconsistent across versions; "
"changes to this function will be done with caution and in a backwards-"
"compatible manner. In particular, the saving of thread-local variables and "
"similar state will be retained across Python versions."
msgstr ""

msgid ""
"The exact behavior of whether this function creates a new thread state is "
"described below, but be aware that this may change in the future."
msgstr ""

msgid ""
"First, this function checks if an attached thread state is present. If there "
"is, this function then checks if the interpreter of that thread state "
"matches the interpreter guarded by *guard*. If that is the case, this "
"function simply marks the thread state as being used by a "
"``PyThreadState_Ensure`` call and returns."
msgstr ""

msgid ""
"If there is no attached thread state, then this function checks if any "
"thread state has been used by the current OS thread. (This is returned by :c:"
"func:`PyGILState_GetThisThreadState`.) If there was, then this function "
"checks if that thread state's interpreter matches *guard*. If it does, it is "
"re-attached and marked as used."
msgstr ""

msgid ""
"Otherwise, if both of the above cases fail, a new thread state is created "
"for *guard*. It is then attached and marked as owned by "
"``PyThreadState_Ensure``."
msgstr ""

msgid "Get an attached thread state for the interpreter referenced by *view*."
msgstr ""

msgid ""
"The behavior and return value are the same as for :c:func:"
"`PyThreadState_Ensure`; additionally, if the function succeeds, the "
"interpreter referenced by *view* will be implicitly guarded. The guard will "
"be released upon the corresponding :c:func:`PyThreadState_Release` call."
msgstr ""

msgid ""
"Undo a :c:func:`PyThreadState_Ensure` or :c:func:"
"`PyThreadState_EnsureFromView` call."
msgstr ""

msgid ""
"This must be called exactly once for each successful *Ensure* call, with "
"*token* set to that call's return value."
msgstr ""

msgid ""
"The state that was attached before the corresponding *Ensure* call (if any) "
"will be attached when :c:func:`PyThreadState_Release` returns."
msgstr ""

msgid ""
"The exact behavior of whether this function deletes a thread state is "
"considered unstable and implementation-dependent."
msgstr ""

msgid ""
"Currently, this function will decrement an internal counter on the attached "
"thread state. If this counter ever reaches below zero, this function emits a "
"fatal error (via :c:func:`Py_FatalError`)."
msgstr ""

msgid ""
"If the attached thread state is owned by ``PyThreadState_Ensure``, then the "
"attached thread state will be deallocated and deleted upon the internal "
"counter reaching zero. Otherwise, nothing happens when the counter reaches "
"zero."
msgstr ""

msgid ""
"An opaque token retrieved from a :c:func:`PyThreadState_Ensure` call and "
"passed to a corresponding :c:func:`PyThreadState_Release` call."
msgstr ""

msgid "GIL-state APIs"
msgstr ""

msgid ""
"The following APIs are generally not compatible with subinterpreters and "
"will hang the process during interpreter finalization (see :ref:`cautions-"
"regarding-runtime-finalization`). As such, these APIs were :term:`soft "
"deprecated` in Python 3.15 in favor of the :ref:`new APIs `."
msgstr ""

msgid ""
"The type of the value returned by :c:func:`PyGILState_Ensure` and passed to :"
"c:func:`PyGILState_Release`."
msgstr ""

msgid "The GIL was already held when :c:func:`PyGILState_Ensure` was called."
msgstr ""

msgid "The GIL was not held when :c:func:`PyGILState_Ensure` was called."
msgstr ""

msgid ""
"Ensure that the current thread is ready to call the Python C API regardless "
"of the current state of Python, or of the :term:`attached thread state`. "
"This may be called as many times as desired by a thread as long as each call "
"is matched with a call to :c:func:`PyGILState_Release`. In general, other "
"thread-related APIs may be used between :c:func:`PyGILState_Ensure` and :c:"
"func:`PyGILState_Release` calls as long as the thread state is restored to "
"its previous state before the Release().  For example, normal usage of the :"
"c:macro:`Py_BEGIN_ALLOW_THREADS` and :c:macro:`Py_END_ALLOW_THREADS` macros "
"is acceptable."
msgstr ""

msgid ""
"The return value is an opaque \"handle\" to the :term:`attached thread "
"state` when :c:func:`PyGILState_Ensure` was called, and must be passed to :c:"
"func:`PyGILState_Release` to ensure Python is left in the same state. Even "
"though recursive calls are allowed, these handles *cannot* be shared - each "
"unique call to :c:func:`PyGILState_Ensure` must save the handle for its call "
"to :c:func:`PyGILState_Release`."
msgstr ""

msgid ""
"When the function returns, there will be an :term:`attached thread state` "
"and the thread will be able to call arbitrary Python code."
msgstr ""

msgid ""
"This function has no way to return an error. As such, errors are either "
"fatal (that is, they send ``SIGABRT`` and crash the process; see :c:func:"
"`Py_FatalError`), or the thread will be permanently blocked (such as during "
"interpreter finalization)."
msgstr ""

msgid ""
"Calling this function when the interpreter is finalizing will infinitely "
"hang the thread, which may cause deadlocks. :ref:`cautions-regarding-runtime-"
"finalization` for more details."
msgstr ""

msgid ""
"In addition, this function generally does not work with subinterpreters when "
"used from foreign threads, because this function has no way of knowing which "
"interpreter created the thread (and as such, will implicitly pick the main "
"interpreter)."
msgstr ""

msgid ""
"Hangs the current thread, rather than terminating it, if called while the "
"interpreter is finalizing."
msgstr ""

msgid ""
"Use :c:func:`PyThreadState_Ensure` or :c:func:`PyThreadState_EnsureFromView` "
"instead."
msgstr ""

msgid ""
"Release any resources previously acquired.  After this call, Python's state "
"will be the same as it was prior to the corresponding :c:func:"
"`PyGILState_Ensure` call (but generally this state will be unknown to the "
"caller, hence the use of the GIL-state API)."
msgstr ""

msgid ""
"Every call to :c:func:`PyGILState_Ensure` must be matched by a call to :c:"
"func:`PyGILState_Release` on the same thread."
msgstr ""

msgid "Use :c:func:`PyThreadState_Release` instead."
msgstr ""

msgid ""
"Get the :term:`thread state` that was most recently :term:`attached "
"` for this thread. (If the most recent thread state "
"has been deleted, this returns ``NULL``.)"
msgstr ""

msgid "If the caller has an attached thread state, it is returned."
msgstr ""

msgid ""
"In other terms, this function returns the thread state that will be used by :"
"c:func:`PyGILState_Ensure`. If this returns ``NULL``, then "
"``PyGILState_Ensure`` will create a new thread state."
msgstr ""

msgid "This function cannot fail."
msgstr ""

msgid ""
"Use :c:func:`PyThreadState_Get` or :c:func:`PyThreadState_GetUnchecked` "
"instead."
msgstr ""

msgid ""
"Return ``1`` if the current thread has an :term:`attached thread state` that "
"matches the thread state returned by :c:func:"
"`PyGILState_GetThisThreadState`. If the caller has no attached thread state "
"or it otherwise doesn't match, then this returns ``0``."
msgstr ""

msgid ""
"If the current Python process has ever created a subinterpreter, this "
"function will *always* return ``1``."
msgstr ""

msgid "This is mainly a helper/diagnostic function."
msgstr ""

msgid "Use ``PyThreadState_GetUnchecked() != NULL`` instead."
msgstr ""

msgid "Cautions about fork()"
msgstr ""

msgid ""
"Another important thing to note about threads is their behaviour in the face "
"of the C :c:func:`fork` call. On most systems with :c:func:`fork`, after a "
"process forks only the thread that issued the fork will exist.  This has a "
"concrete impact both on how locks must be handled and on all stored state in "
"CPython's runtime."
msgstr ""

msgid ""
"The fact that only the \"current\" thread remains means any locks held by "
"other threads will never be released. Python solves this for :func:`os.fork` "
"by acquiring the locks it uses internally before the fork, and releasing "
"them afterwards. In addition, it resets any :ref:`lock-objects` in the "
"child. When extending or embedding Python, there is no way to inform Python "
"of additional (non-Python) locks that need to be acquired before or reset "
"after a fork. OS facilities such as :c:func:`!pthread_atfork` would need to "
"be used to accomplish the same thing. Additionally, when extending or "
"embedding Python, calling :c:func:`fork` directly rather than through :func:"
"`os.fork` (and returning to or calling into Python) may result in a deadlock "
"by one of Python's internal locks being held by a thread that is defunct "
"after the fork. :c:func:`PyOS_AfterFork_Child` tries to reset the necessary "
"locks, but is not always able to."
msgstr ""

msgid ""
"The fact that all other threads go away also means that CPython's runtime "
"state there must be cleaned up properly, which :func:`os.fork` does.  This "
"means finalizing all other :c:type:`PyThreadState` objects belonging to the "
"current interpreter and all other :c:type:`PyInterpreterState` objects.  Due "
"to this and the special nature of the :ref:`\"main\" interpreter `, :c:func:`fork` should only be called in that "
"interpreter's \"main\" thread, where the CPython global runtime was "
"originally initialized. The only exception is if :c:func:`exec` will be "
"called immediately after."
msgstr ""

msgid "High-level APIs"
msgstr "Wysokopoziomowe interfejsy API"

msgid ""
"These are the most commonly used types and functions when writing multi-"
"threaded C extensions."
msgstr ""

msgid ""
"This data structure represents the state of a single thread.  The only "
"public data member is:"
msgstr ""

msgid "This thread's interpreter state."
msgstr ""

msgid "Deprecated function which does nothing."
msgstr ""

msgid ""
"In Python 3.6 and older, this function created the GIL if it didn't exist."
msgstr ""

msgid "The function now does nothing."
msgstr ""

msgid ""
"This function is now called by :c:func:`Py_Initialize()`, so you don't have "
"to call it yourself anymore."
msgstr ""

msgid ""
"This function cannot be called before :c:func:`Py_Initialize()` anymore."
msgstr ""

msgid ""
"Detach the :term:`attached thread state` and return it. The thread will have "
"no :term:`thread state` upon returning."
msgstr ""

msgid ""
"Set the :term:`attached thread state` to *tstate*. The passed :term:`thread "
"state` **should not** be :term:`attached `, otherwise "
"deadlock ensues. *tstate* will be attached upon returning."
msgstr ""

msgid ""
"Calling this function from a thread when the runtime is finalizing will hang "
"the thread until the program exits, even if the thread was not created by "
"Python.  Refer to :ref:`cautions-regarding-runtime-finalization` for more "
"details."
msgstr ""

msgid ""
"Return the :term:`attached thread state`. If the thread has no attached "
"thread state, (such as when inside of :c:macro:`Py_BEGIN_ALLOW_THREADS` "
"block), then this issues a fatal error (so that the caller needn't check for "
"``NULL``)."
msgstr ""

msgid "See also :c:func:`PyThreadState_GetUnchecked`."
msgstr ""

msgid ""
"Similar to :c:func:`PyThreadState_Get`, but don't kill the process with a "
"fatal error if it is NULL. The caller is responsible to check if the result "
"is NULL."
msgstr ""

msgid ""
"In Python 3.5 to 3.12, the function was private and known as "
"``_PyThreadState_UncheckedGet()``."
msgstr ""

msgid ""
"Set the :term:`attached thread state` to *tstate*, and return the :term:"
"`thread state` that was attached prior to calling."
msgstr ""

msgid ""
"This function is safe to call without an :term:`attached thread state`; it "
"will simply return ``NULL`` indicating that there was no prior thread state."
msgstr ""

msgid ":c:func:`PyEval_ReleaseThread`"
msgstr ""

msgid ""
"Similar to :c:func:`PyGILState_Ensure`, this function will hang the thread "
"if the runtime is finalizing."
msgstr ""

msgid "Low-level APIs"
msgstr "niskopoziomowe interfejsy API"

msgid ""
"Create a new thread state object belonging to the given interpreter object. "
"An :term:`attached thread state` is not needed."
msgstr ""

msgid ""
"Reset all information in a :term:`thread state` object.  *tstate* must be :"
"term:`attached `"
msgstr ""

msgid ""
"This function now calls the :c:member:`!PyThreadState.on_delete` callback. "
"Previously, that happened in :c:func:`PyThreadState_Delete`."
msgstr ""

msgid "The :c:member:`!PyThreadState.on_delete` callback was removed."
msgstr ""

msgid ""
"Destroy a :term:`thread state` object.  *tstate* should not be :term:"
"`attached ` to any thread. *tstate* must have been "
"reset with a previous call to :c:func:`PyThreadState_Clear`."
msgstr ""

msgid ""
"Detach the :term:`attached thread state` (which must have been reset with a "
"previous call to :c:func:`PyThreadState_Clear`) and then destroy it."
msgstr ""

msgid ""
"No :term:`thread state` will be :term:`attached ` "
"upon returning."
msgstr ""

msgid "Get the current frame of the Python thread state *tstate*."
msgstr ""

msgid ""
"Return a :term:`strong reference`. Return ``NULL`` if no frame is currently "
"executing."
msgstr ""

msgid "See also :c:func:`PyEval_GetFrame`."
msgstr ""

msgid ""
"*tstate* must not be ``NULL``, and must be :term:`attached `."
msgstr ""

msgid ""
"Get the unique :term:`thread state` identifier of the Python thread state "
"*tstate*."
msgstr ""

msgid "Get the interpreter of the Python thread state *tstate*."
msgstr ""

msgid "Suspend tracing and profiling in the Python thread state *tstate*."
msgstr ""

msgid "Resume them using the :c:func:`PyThreadState_LeaveTracing` function."
msgstr ""

msgid ""
"Resume tracing and profiling in the Python thread state *tstate* suspended "
"by the :c:func:`PyThreadState_EnterTracing` function."
msgstr ""

msgid ""
"See also :c:func:`PyEval_SetTrace` and :c:func:`PyEval_SetProfile` functions."
msgstr ""

msgid ""
"Set the stack protection start address and stack protection size of a Python "
"thread state."
msgstr ""

msgid ""
"On success, return ``0``. On failure, set an exception and return ``-1``."
msgstr ""

msgid ""
"CPython implements :ref:`recursion control ` for C code by "
"raising :py:exc:`RecursionError` when it notices that the machine execution "
"stack is close to overflow. See for example the :c:func:"
"`Py_EnterRecursiveCall` function. For this, it needs to know the location of "
"the current thread's stack, which it normally gets from the operating "
"system. When the stack is changed, for example using context switching "
"techniques like the Boost library's ``boost::context``, you must call :c:"
"func:`~PyUnstable_ThreadState_SetStackProtection` to inform CPython of the "
"change."
msgstr ""

msgid ""
"Call :c:func:`~PyUnstable_ThreadState_SetStackProtection` either before or "
"after changing the stack. Do not call any other Python C API between the "
"call and the stack change."
msgstr ""

msgid ""
"See :c:func:`PyUnstable_ThreadState_ResetStackProtection` for undoing this "
"operation."
msgstr ""

msgid ""
"Reset the stack protection start address and stack protection size of a "
"Python thread state to the operating system defaults."
msgstr ""

msgid ""
"See :c:func:`PyUnstable_ThreadState_SetStackProtection` for an explanation."
msgstr ""

msgid ""
"Return a dictionary in which extensions can store thread-specific state "
"information.  Each extension should use a unique key to use to store state "
"in the dictionary.  It is okay to call this function when no :term:`thread "
"state` is :term:`attached `. If this function returns "
"``NULL``, no exception has been raised and the caller should assume no "
"thread state is attached."
msgstr ""

msgid ""
":term:`Attach ` *tstate* to the current thread, which "
"must not be ``NULL`` or already :term:`attached `."
msgstr ""

msgid ""
"The calling thread must not already have an :term:`attached thread state`."
msgstr ""

msgid ""
"Updated to be consistent with :c:func:`PyEval_RestoreThread`, :c:func:"
"`Py_END_ALLOW_THREADS`, and :c:func:`PyGILState_Ensure`, and terminate the "
"current thread if called while the interpreter is finalizing."
msgstr ""

msgid ""
":c:func:`PyEval_RestoreThread` is a higher-level function which is always "
"available (even when threads have not been initialized)."
msgstr ""

msgid ""
"Detach the :term:`attached thread state`. The *tstate* argument, which must "
"not be ``NULL``, is only used to check that it represents the :term:"
"`attached thread state` --- if it isn't, a fatal error is reported."
msgstr ""

msgid ""
":c:func:`PyEval_SaveThread` is a higher-level function which is always "
"available (even when threads have not been initialized)."
msgstr ""

msgid "Asynchronous notifications"
msgstr ""

msgid ""
"A mechanism is provided to make asynchronous notifications to the main "
"interpreter thread.  These notifications take the form of a function pointer "
"and a void pointer argument."
msgstr ""

msgid ""
"Schedule a function to be called from the main interpreter thread.  On "
"success, ``0`` is returned and *func* is queued for being called in the main "
"thread.  On failure, ``-1`` is returned without setting any exception."
msgstr ""

msgid ""
"When successfully queued, *func* will be *eventually* called from the main "
"interpreter thread with the argument *arg*.  It will be called "
"asynchronously with respect to normally running Python code, but with both "
"these conditions met:"
msgstr ""

msgid "on a :term:`bytecode` boundary;"
msgstr ""

msgid ""
"with the main thread holding an :term:`attached thread state` (*func* can "
"therefore use the full C API)."
msgstr ""

msgid ""
"*func* must return ``0`` on success, or ``-1`` on failure with an exception "
"set.  *func* won't be interrupted to perform another asynchronous "
"notification recursively, but it can still be interrupted to switch threads "
"if the :term:`thread state ` is detached."
msgstr ""

msgid ""
"This function doesn't need an :term:`attached thread state`. However, to "
"call this function in a subinterpreter, the caller must have an :term:"
"`attached thread state`. Otherwise, the function *func* can be scheduled to "
"be called from the wrong interpreter."
msgstr ""

msgid ""
"This is a low-level function, only useful for very special cases. There is "
"no guarantee that *func* will be called as quick as possible.  If the main "
"thread is busy executing a system call, *func* won't be called before the "
"system call returns.  This function is generally **not** suitable for "
"calling Python code from arbitrary C threads.  Instead, use :c:func:"
"`PyThreadState_EnsureFromView`."
msgstr ""

msgid ""
"If this function is called in a subinterpreter, the function *func* is now "
"scheduled to be called from the subinterpreter, rather than being called "
"from the main interpreter. Each subinterpreter now has its own list of "
"scheduled calls."
msgstr ""

msgid ""
"This function now always schedules *func* to be run in the main interpreter."
msgstr ""

msgid ""
"Execute all pending calls. This is usually executed automatically by the "
"interpreter."
msgstr ""

msgid ""
"This function returns ``0`` on success, and returns ``-1`` with an exception "
"set on failure."
msgstr ""

msgid ""
"If this is not called in the main thread of the main interpreter, this "
"function does nothing and returns ``0``. The caller must hold an :term:"
"`attached thread state`."
msgstr ""

msgid "This function only runs pending calls in the main interpreter."
msgstr ""

msgid ""
"Schedule an exception to be raised asynchronously in a thread. If the thread "
"has a previously scheduled exception, it is overwritten."
msgstr ""

msgid ""
"The *id* argument is the thread id of the target thread, as returned by :c:"
"func:`PyThread_get_thread_ident`. *exc* is the class of the exception to be "
"raised, or ``NULL`` to clear the pending exception (if any)."
msgstr ""

msgid ""
"Return the number of affected thread states. This is normally ``1`` if *id* "
"is found, even when no change was made (the given *exc* was already pending, "
"or *exc* is ``NULL`` but no exception is pending). If the thread id isn't "
"found, return ``0``.  This raises no exceptions."
msgstr ""

msgid ""
"To prevent naive misuse, you must write your own C extension to call this. "
"This function must be called with an :term:`attached thread state`. This "
"function does not :term:`steal` any references to *exc*. This function does "
"not necessarily interrupt system calls such as :py:func:`~time.sleep`."
msgstr ""

msgid ""
"The type of the *id* parameter changed from :c:expr:`long` to :c:expr:"
"`unsigned long`."
msgstr ""

msgid "Operating system thread APIs"
msgstr ""

msgid "Sentinel value for an invalid thread ID."
msgstr ""

msgid "This is currently equivalent to ``(unsigned long)-1``."
msgstr ""

msgid ""
"Start function *func* in a new thread with argument *arg*. The resulting "
"thread is not intended to be joined."
msgstr ""

msgid "*func* must not be ``NULL``, but *arg* may be ``NULL``."
msgstr ""

msgid ""
"On success, this function returns the identifier of the new thread; on "
"failure, this returns :c:macro:`PYTHREAD_INVALID_THREAD_ID`."
msgstr ""

msgid "The caller does not need to hold an :term:`attached thread state`."
msgstr ""

msgid "Return the identifier of the current thread, which will never be zero."
msgstr ""

msgid ""
"This function cannot fail, and the caller does not need to hold an :term:"
"`attached thread state`."
msgstr ""

msgid ""
":py:func:`threading.get_ident` and :py:attr:`threading.Thread.ident` expose "
"this identifier to Python."
msgstr ""

msgid ""
"Get general information about the current thread in the form of a :ref:"
"`struct sequence ` object. This information is "
"accessible as :py:attr:`sys.thread_info` in Python."
msgstr ""

msgid ""
"On success, this returns a new :term:`strong reference` to the thread "
"information; on failure, this returns ``NULL`` with an exception set."
msgstr ""

msgid "The caller must hold an :term:`attached thread state`."
msgstr ""

msgid "This macro is defined when the system supports native thread IDs."
msgstr ""

msgid ""
"Get the native identifier of the current thread as it was assigned by the "
"operating system's kernel, which will never be less than zero."
msgstr ""

msgid ""
"This function is only available when :c:macro:`PY_HAVE_THREAD_NATIVE_ID` is "
"defined."
msgstr ""

msgid ":py:func:`threading.get_native_id`"
msgstr ""

msgid ""
"Terminate the current thread. This function is generally considered unsafe "
"and should be avoided. It is kept solely for backwards compatibility."
msgstr ""

msgid ""
"This function is only safe to call if all functions in the full call stack "
"are written to safely allow it."
msgstr ""

msgid ""
"If the current system uses POSIX threads (also known as \"pthreads\"), this "
"calls :manpage:`pthread_exit(3)`, which attempts to unwind the stack and "
"call C++ destructors on some libc implementations. However, if a "
"``noexcept`` function is reached, it may terminate the process. Other "
"systems, such as macOS, do unwinding."
msgstr ""

msgid ""
"On Windows, this function calls ``_endthreadex()``, which kills the thread "
"without calling C++ destructors."
msgstr ""

msgid "In any case, there is a risk of corruption on the thread's stack."
msgstr ""

msgid ""
"Initialize ``PyThread*`` APIs. Python executes this function automatically, "
"so there's little need to call it from an extension module."
msgstr ""

msgid "Set the stack size of the current thread to *size* bytes."
msgstr ""

msgid ""
"This function returns ``0`` on success, ``-1`` if *size* is invalid, or "
"``-2`` if the system does not support changing the stack size. This function "
"does not set exceptions."
msgstr ""

msgid ""
"Return the stack size of the current thread in bytes, or ``0`` if the "
"system's default stack size is in use."
msgstr ""

msgid "global interpreter lock"
msgstr ""

msgid "interpreter lock"
msgstr ""

msgid "lock, interpreter"
msgstr ""

msgid "setswitchinterval (in module sys)"
msgstr ""

msgid "PyThreadState (C type)"
msgstr ""

msgid "Py_BEGIN_ALLOW_THREADS (C macro)"
msgstr ""

msgid "Py_END_ALLOW_THREADS (C macro)"
msgstr ""

msgid "PyEval_RestoreThread (C function)"
msgstr ""

msgid "PyEval_SaveThread (C function)"
msgstr ""

msgid "PyEval_AcquireThread()"
msgstr ""

msgid "PyEval_ReleaseThread()"
msgstr ""

msgid "PyEval_SaveThread()"
msgstr ""

msgid "PyEval_RestoreThread()"
msgstr ""

msgid "module"
msgstr "modu"

msgid "_thread"
msgstr ""