@plone/volto 14.0.0 → 14.1.1

package/include/python3.8/pystate.h

@@ -1,136 +0,0 @@
-/* Thread and interpreter state structures and their interfaces */
-
-
-#ifndef Py_PYSTATE_H
-#define Py_PYSTATE_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#include "pythread.h"
-
-/* This limitation is for performance and simplicity. If needed it can be
-removed (with effort). */
-#define MAX_CO_EXTRA_USERS 255
-
-/* Forward declarations for PyFrameObject, PyThreadState
-   and PyInterpreterState */
-struct _frame;
-struct _ts;
-struct _is;
-
-/* struct _ts is defined in cpython/pystate.h */
-typedef struct _ts PyThreadState;
-/* struct _is is defined in internal/pycore_pystate.h */
-typedef struct _is PyInterpreterState;
-
-PyAPI_FUNC(PyInterpreterState *) PyInterpreterState_New(void);
-PyAPI_FUNC(void) PyInterpreterState_Clear(PyInterpreterState *);
-PyAPI_FUNC(void) PyInterpreterState_Delete(PyInterpreterState *);
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03080000
-/* New in 3.8 */
-PyAPI_FUNC(PyObject *) PyInterpreterState_GetDict(PyInterpreterState *);
-#endif
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
-/* New in 3.7 */
-PyAPI_FUNC(int64_t) PyInterpreterState_GetID(PyInterpreterState *);
-#endif
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-
-/* State unique per thread */
-
-/* New in 3.3 */
-PyAPI_FUNC(int) PyState_AddModule(PyObject*, struct PyModuleDef*);
-PyAPI_FUNC(int) PyState_RemoveModule(struct PyModuleDef*);
-#endif
-PyAPI_FUNC(PyObject*) PyState_FindModule(struct PyModuleDef*);
-
-PyAPI_FUNC(PyThreadState *) PyThreadState_New(PyInterpreterState *);
-PyAPI_FUNC(void) PyThreadState_Clear(PyThreadState *);
-PyAPI_FUNC(void) PyThreadState_Delete(PyThreadState *);
-PyAPI_FUNC(void) PyThreadState_DeleteCurrent(void);
-
-/* Get the current thread state.
-
-   When the current thread state is NULL, this issues a fatal error (so that
-   the caller needn't check for NULL).
-
-   The caller must hold the GIL.
-
-   See also PyThreadState_GET() and _PyThreadState_GET(). */
-PyAPI_FUNC(PyThreadState *) PyThreadState_Get(void);
-
-/* Get the current Python thread state.
-
-   Macro using PyThreadState_Get() or _PyThreadState_GET() depending if
-   pycore_pystate.h is included or not (this header redefines the macro).
-
-   If PyThreadState_Get() is used, issue a fatal error if the current thread
-   state is NULL.
-
-   See also PyThreadState_Get() and _PyThreadState_GET(). */
-#define PyThreadState_GET() PyThreadState_Get()
-
-PyAPI_FUNC(PyThreadState *) PyThreadState_Swap(PyThreadState *);
-PyAPI_FUNC(PyObject *) PyThreadState_GetDict(void);
-PyAPI_FUNC(int) PyThreadState_SetAsyncExc(unsigned long, PyObject *);
-
-typedef
-    enum {PyGILState_LOCKED, PyGILState_UNLOCKED}
-        PyGILState_STATE;
-
-
-/* Ensure that the current thread is ready to call the Python
-   C API, regardless of the current state of Python, or of its
-   thread lock.  This may be called as many times as desired
-   by a thread so long as each call is matched with a call to
-   PyGILState_Release().  In general, other thread-state APIs may
-   be used between _Ensure() and _Release() calls, so long as the
-   thread-state is restored to its previous state before the Release().
-   For example, normal use of the Py_BEGIN_ALLOW_THREADS/
-   Py_END_ALLOW_THREADS macros are acceptable.
-
-   The return value is an opaque "handle" to the thread state when
-   PyGILState_Ensure() was called, and must be passed to
-   PyGILState_Release() to ensure Python is left in the same state. Even
-   though recursive calls are allowed, these handles can *not* be shared -
-   each unique call to PyGILState_Ensure must save the handle for its
-   call to PyGILState_Release.
-
-   When the function returns, the current thread will hold the GIL.
-
-   Failure is a fatal error.
-*/
-PyAPI_FUNC(PyGILState_STATE) PyGILState_Ensure(void);
-
-/* Release any resources previously acquired.  After this call, Python's
-   state will be the same as it was prior to the corresponding
-   PyGILState_Ensure() call (but generally this state will be unknown to
-   the caller, hence the use of the GILState API.)
-
-   Every call to PyGILState_Ensure must be matched by a call to
-   PyGILState_Release on the same thread.
-*/
-PyAPI_FUNC(void) PyGILState_Release(PyGILState_STATE);
-
-/* Helper/diagnostic function - get the current thread state for
-   this thread.  May return NULL if no GILState API has been used
-   on the current thread.  Note that the main thread always has such a
-   thread-state, even if no auto-thread-state call has been made
-   on the main thread.
-*/
-PyAPI_FUNC(PyThreadState *) PyGILState_GetThisThreadState(void);
-
-
-#ifndef Py_LIMITED_API
-#  define Py_CPYTHON_PYSTATE_H
-#  include  "cpython/pystate.h"
-#  undef Py_CPYTHON_PYSTATE_H
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_PYSTATE_H */

package/include/python3.8/pystrcmp.h

@@ -1,23 +0,0 @@
-#ifndef Py_STRCMP_H
-#define Py_STRCMP_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-PyAPI_FUNC(int) PyOS_mystrnicmp(const char *, const char *, Py_ssize_t);
-PyAPI_FUNC(int) PyOS_mystricmp(const char *, const char *);
-
-#ifdef MS_WINDOWS
-#define PyOS_strnicmp strnicmp
-#define PyOS_stricmp stricmp
-#else
-#define PyOS_strnicmp PyOS_mystrnicmp
-#define PyOS_stricmp PyOS_mystricmp
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_STRCMP_H */

package/include/python3.8/pystrhex.h

@@ -1,22 +0,0 @@
-#ifndef Py_STRHEX_H
-#define Py_STRHEX_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-/* Returns a str() containing the hex representation of argbuf. */
-PyAPI_FUNC(PyObject*) _Py_strhex(const char* argbuf, const Py_ssize_t arglen);
-/* Returns a bytes() containing the ASCII hex representation of argbuf. */
-PyAPI_FUNC(PyObject*) _Py_strhex_bytes(const char* argbuf, const Py_ssize_t arglen);
-/* These variants include support for a separator between every N bytes: */
-PyAPI_FUNC(PyObject*) _Py_strhex_with_sep(const char* argbuf, const Py_ssize_t arglen, const PyObject* sep, const int bytes_per_group);
-PyAPI_FUNC(PyObject*) _Py_strhex_bytes_with_sep(const char* argbuf, const Py_ssize_t arglen, const PyObject* sep, const int bytes_per_group);
-#endif /* !Py_LIMITED_API */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_STRHEX_H */

package/include/python3.8/pystrtod.h

@@ -1,45 +0,0 @@
-#ifndef Py_STRTOD_H
-#define Py_STRTOD_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-PyAPI_FUNC(double) PyOS_string_to_double(const char *str,
-                                         char **endptr,
-                                         PyObject *overflow_exception);
-
-/* The caller is responsible for calling PyMem_Free to free the buffer
-   that's is returned. */
-PyAPI_FUNC(char *) PyOS_double_to_string(double val,
-                                         char format_code,
-                                         int precision,
-                                         int flags,
-                                         int *type);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) _Py_string_to_number_with_underscores(
-    const char *str, Py_ssize_t len, const char *what, PyObject *obj, void *arg,
-    PyObject *(*innerfunc)(const char *, Py_ssize_t, void *));
-
-PyAPI_FUNC(double) _Py_parse_inf_or_nan(const char *p, char **endptr);
-#endif
-
-
-/* PyOS_double_to_string's "flags" parameter can be set to 0 or more of: */
-#define Py_DTSF_SIGN      0x01 /* always add the sign */
-#define Py_DTSF_ADD_DOT_0 0x02 /* if the result is an integer add ".0" */
-#define Py_DTSF_ALT       0x04 /* "alternate" formatting. it's format_code
-                                  specific */
-
-/* PyOS_double_to_string's "type", if non-NULL, will be set to one of: */
-#define Py_DTST_FINITE 0
-#define Py_DTST_INFINITE 1
-#define Py_DTST_NAN 2
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_STRTOD_H */

package/include/python3.8/pythonrun.h

@@ -1,210 +0,0 @@
-
-/* Interfaces to parse and execute pieces of python code */
-
-#ifndef Py_PYTHONRUN_H
-#define Py_PYTHONRUN_H
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(int) PyRun_SimpleStringFlags(const char *, PyCompilerFlags *);
-PyAPI_FUNC(int) PyRun_AnyFileExFlags(
-    FILE *fp,
-    const char *filename,       /* decoded from the filesystem encoding */
-    int closeit,
-    PyCompilerFlags *flags);
-PyAPI_FUNC(int) PyRun_SimpleFileExFlags(
-    FILE *fp,
-    const char *filename,       /* decoded from the filesystem encoding */
-    int closeit,
-    PyCompilerFlags *flags);
-PyAPI_FUNC(int) PyRun_InteractiveOneFlags(
-    FILE *fp,
-    const char *filename,       /* decoded from the filesystem encoding */
-    PyCompilerFlags *flags);
-PyAPI_FUNC(int) PyRun_InteractiveOneObject(
-    FILE *fp,
-    PyObject *filename,
-    PyCompilerFlags *flags);
-PyAPI_FUNC(int) PyRun_InteractiveLoopFlags(
-    FILE *fp,
-    const char *filename,       /* decoded from the filesystem encoding */
-    PyCompilerFlags *flags);
-
-PyAPI_FUNC(struct _mod *) PyParser_ASTFromString(
-    const char *s,
-    const char *filename,       /* decoded from the filesystem encoding */
-    int start,
-    PyCompilerFlags *flags,
-    PyArena *arena);
-PyAPI_FUNC(struct _mod *) PyParser_ASTFromStringObject(
-    const char *s,
-    PyObject *filename,
-    int start,
-    PyCompilerFlags *flags,
-    PyArena *arena);
-PyAPI_FUNC(struct _mod *) PyParser_ASTFromFile(
-    FILE *fp,
-    const char *filename,       /* decoded from the filesystem encoding */
-    const char* enc,
-    int start,
-    const char *ps1,
-    const char *ps2,
-    PyCompilerFlags *flags,
-    int *errcode,
-    PyArena *arena);
-PyAPI_FUNC(struct _mod *) PyParser_ASTFromFileObject(
-    FILE *fp,
-    PyObject *filename,
-    const char* enc,
-    int start,
-    const char *ps1,
-    const char *ps2,
-    PyCompilerFlags *flags,
-    int *errcode,
-    PyArena *arena);
-#endif
-
-#ifndef PyParser_SimpleParseString
-#define PyParser_SimpleParseString(S, B) \
-    PyParser_SimpleParseStringFlags(S, B, 0)
-#define PyParser_SimpleParseFile(FP, S, B) \
-    PyParser_SimpleParseFileFlags(FP, S, B, 0)
-#endif
-PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlags(const char *, int,
-                                                           int);
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(struct _node *) PyParser_SimpleParseStringFlagsFilename(const char *,
-                                                                   const char *,
-                                                                   int, int);
-#endif
-PyAPI_FUNC(struct _node *) PyParser_SimpleParseFileFlags(FILE *, const char *,
-                                                         int, int);
-
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) PyRun_StringFlags(const char *, int, PyObject *,
-                                         PyObject *, PyCompilerFlags *);
-
-PyAPI_FUNC(PyObject *) PyRun_FileExFlags(
-    FILE *fp,
-    const char *filename,       /* decoded from the filesystem encoding */
-    int start,
-    PyObject *globals,
-    PyObject *locals,
-    int closeit,
-    PyCompilerFlags *flags);
-#endif
-
-#ifdef Py_LIMITED_API
-PyAPI_FUNC(PyObject *) Py_CompileString(const char *, const char *, int);
-#else
-#define Py_CompileString(str, p, s) Py_CompileStringExFlags(str, p, s, NULL, -1)
-#define Py_CompileStringFlags(str, p, s, f) Py_CompileStringExFlags(str, p, s, f, -1)
-PyAPI_FUNC(PyObject *) Py_CompileStringExFlags(
-    const char *str,
-    const char *filename,       /* decoded from the filesystem encoding */
-    int start,
-    PyCompilerFlags *flags,
-    int optimize);
-PyAPI_FUNC(PyObject *) Py_CompileStringObject(
-    const char *str,
-    PyObject *filename, int start,
-    PyCompilerFlags *flags,
-    int optimize);
-#endif
-PyAPI_FUNC(struct symtable *) Py_SymtableString(
-    const char *str,
-    const char *filename,       /* decoded from the filesystem encoding */
-    int start);
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(const char *) _Py_SourceAsString(
-    PyObject *cmd,
-    const char *funcname,
-    const char *what,
-    PyCompilerFlags *cf,
-    PyObject **cmd_copy);
-
-PyAPI_FUNC(struct symtable *) Py_SymtableStringObject(
-    const char *str,
-    PyObject *filename,
-    int start);
-
-PyAPI_FUNC(struct symtable *) _Py_SymtableStringObjectFlags(
-    const char *str,
-    PyObject *filename,
-    int start,
-    PyCompilerFlags *flags);
-#endif
-
-PyAPI_FUNC(void) PyErr_Print(void);
-PyAPI_FUNC(void) PyErr_PrintEx(int);
-PyAPI_FUNC(void) PyErr_Display(PyObject *, PyObject *, PyObject *);
-
-#ifndef Py_LIMITED_API
-/* A function flavor is also exported by libpython. It is required when
-    libpython is accessed directly rather than using header files which defines
-    macros below. On Windows, for example, PyAPI_FUNC() uses dllexport to
-    export functions in pythonXX.dll. */
-PyAPI_FUNC(PyObject *) PyRun_String(const char *str, int s, PyObject *g, PyObject *l);
-PyAPI_FUNC(int) PyRun_AnyFile(FILE *fp, const char *name);
-PyAPI_FUNC(int) PyRun_AnyFileEx(FILE *fp, const char *name, int closeit);
-PyAPI_FUNC(int) PyRun_AnyFileFlags(FILE *, const char *, PyCompilerFlags *);
-PyAPI_FUNC(int) PyRun_SimpleString(const char *s);
-PyAPI_FUNC(int) PyRun_SimpleFile(FILE *f, const char *p);
-PyAPI_FUNC(int) PyRun_SimpleFileEx(FILE *f, const char *p, int c);
-PyAPI_FUNC(int) PyRun_InteractiveOne(FILE *f, const char *p);
-PyAPI_FUNC(int) PyRun_InteractiveLoop(FILE *f, const char *p);
-PyAPI_FUNC(PyObject *) PyRun_File(FILE *fp, const char *p, int s, PyObject *g, PyObject *l);
-PyAPI_FUNC(PyObject *) PyRun_FileEx(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, int c);
-PyAPI_FUNC(PyObject *) PyRun_FileFlags(FILE *fp, const char *p, int s, PyObject *g, PyObject *l, PyCompilerFlags *flags);
-
-/* Use macros for a bunch of old variants */
-#define PyRun_String(str, s, g, l) PyRun_StringFlags(str, s, g, l, NULL)
-#define PyRun_AnyFile(fp, name) PyRun_AnyFileExFlags(fp, name, 0, NULL)
-#define PyRun_AnyFileEx(fp, name, closeit) \
-    PyRun_AnyFileExFlags(fp, name, closeit, NULL)
-#define PyRun_AnyFileFlags(fp, name, flags) \
-    PyRun_AnyFileExFlags(fp, name, 0, flags)
-#define PyRun_SimpleString(s) PyRun_SimpleStringFlags(s, NULL)
-#define PyRun_SimpleFile(f, p) PyRun_SimpleFileExFlags(f, p, 0, NULL)
-#define PyRun_SimpleFileEx(f, p, c) PyRun_SimpleFileExFlags(f, p, c, NULL)
-#define PyRun_InteractiveOne(f, p) PyRun_InteractiveOneFlags(f, p, NULL)
-#define PyRun_InteractiveLoop(f, p) PyRun_InteractiveLoopFlags(f, p, NULL)
-#define PyRun_File(fp, p, s, g, l) \
-    PyRun_FileExFlags(fp, p, s, g, l, 0, NULL)
-#define PyRun_FileEx(fp, p, s, g, l, c) \
-    PyRun_FileExFlags(fp, p, s, g, l, c, NULL)
-#define PyRun_FileFlags(fp, p, s, g, l, flags) \
-    PyRun_FileExFlags(fp, p, s, g, l, 0, flags)
-#endif
-
-/* Stuff with no proper home (yet) */
-#ifndef Py_LIMITED_API
-PyAPI_FUNC(char *) PyOS_Readline(FILE *, FILE *, const char *);
-#endif
-PyAPI_DATA(int) (*PyOS_InputHook)(void);
-PyAPI_DATA(char) *(*PyOS_ReadlineFunctionPointer)(FILE *, FILE *, const char *);
-#ifndef Py_LIMITED_API
-PyAPI_DATA(PyThreadState*) _PyOS_ReadlineTState;
-#endif
-
-/* Stack size, in "pointers" (so we get extra safety margins
-   on 64-bit platforms).  On a 32-bit platform, this translates
-   to an 8k margin. */
-#define PYOS_STACK_MARGIN 2048
-
-#if defined(WIN32) && !defined(MS_WIN64) && !defined(_M_ARM) && defined(_MSC_VER) && _MSC_VER >= 1300
-/* Enable stack checking under Microsoft C */
-#define USE_STACKCHECK
-#endif
-
-#ifdef USE_STACKCHECK
-/* Check that we aren't overflowing our stack */
-PyAPI_FUNC(int) PyOS_CheckStack(void);
-#endif
-
-#ifdef __cplusplus
-}
-#endif
-#endif /* !Py_PYTHONRUN_H */

package/include/python3.8/pythread.h

@@ -1,161 +0,0 @@
-
-#ifndef Py_PYTHREAD_H
-#define Py_PYTHREAD_H
-
-typedef void *PyThread_type_lock;
-typedef void *PyThread_type_sema;
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Return status codes for Python lock acquisition.  Chosen for maximum
- * backwards compatibility, ie failure -> 0, success -> 1.  */
-typedef enum PyLockStatus {
-    PY_LOCK_FAILURE = 0,
-    PY_LOCK_ACQUIRED = 1,
-    PY_LOCK_INTR
-} PyLockStatus;
-
-#ifndef Py_LIMITED_API
-#define PYTHREAD_INVALID_THREAD_ID ((unsigned long)-1)
-#endif
-
-PyAPI_FUNC(void) PyThread_init_thread(void);
-PyAPI_FUNC(unsigned long) PyThread_start_new_thread(void (*)(void *), void *);
-PyAPI_FUNC(void) _Py_NO_RETURN PyThread_exit_thread(void);
-PyAPI_FUNC(unsigned long) PyThread_get_thread_ident(void);
-
-#if defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__NetBSD__) || defined(_WIN32) || defined(_AIX)
-#define PY_HAVE_THREAD_NATIVE_ID
-PyAPI_FUNC(unsigned long) PyThread_get_thread_native_id(void);
-#endif
-
-PyAPI_FUNC(PyThread_type_lock) PyThread_allocate_lock(void);
-PyAPI_FUNC(void) PyThread_free_lock(PyThread_type_lock);
-PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock, int);
-#define WAIT_LOCK       1
-#define NOWAIT_LOCK     0
-
-/* PY_TIMEOUT_T is the integral type used to specify timeouts when waiting
-   on a lock (see PyThread_acquire_lock_timed() below).
-   PY_TIMEOUT_MAX is the highest usable value (in microseconds) of that
-   type, and depends on the system threading API.
-
-   NOTE: this isn't the same value as `_thread.TIMEOUT_MAX`.  The _thread
-   module exposes a higher-level API, with timeouts expressed in seconds
-   and floating-point numbers allowed.
-*/
-#define PY_TIMEOUT_T long long
-
-#if defined(_POSIX_THREADS)
-   /* PyThread_acquire_lock_timed() uses _PyTime_FromNanoseconds(us * 1000),
-      convert microseconds to nanoseconds. */
-#  define PY_TIMEOUT_MAX (PY_LLONG_MAX / 1000)
-#elif defined (NT_THREADS)
-   /* In the NT API, the timeout is a DWORD and is expressed in milliseconds */
-#  if 0xFFFFFFFFLL * 1000 < PY_LLONG_MAX
-#    define PY_TIMEOUT_MAX (0xFFFFFFFFLL * 1000)
-#  else
-#    define PY_TIMEOUT_MAX PY_LLONG_MAX
-#  endif
-#else
-#  define PY_TIMEOUT_MAX PY_LLONG_MAX
-#endif
-
-
-/* If microseconds == 0, the call is non-blocking: it returns immediately
-   even when the lock can't be acquired.
-   If microseconds > 0, the call waits up to the specified duration.
-   If microseconds < 0, the call waits until success (or abnormal failure)
-
-   microseconds must be less than PY_TIMEOUT_MAX. Behaviour otherwise is
-   undefined.
-
-   If intr_flag is true and the acquire is interrupted by a signal, then the
-   call will return PY_LOCK_INTR.  The caller may reattempt to acquire the
-   lock.
-*/
-PyAPI_FUNC(PyLockStatus) PyThread_acquire_lock_timed(PyThread_type_lock,
-                                                     PY_TIMEOUT_T microseconds,
-                                                     int intr_flag);
-
-PyAPI_FUNC(void) PyThread_release_lock(PyThread_type_lock);
-
-PyAPI_FUNC(size_t) PyThread_get_stacksize(void);
-PyAPI_FUNC(int) PyThread_set_stacksize(size_t);
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03030000
-PyAPI_FUNC(PyObject*) PyThread_GetInfo(void);
-#endif
-
-
-/* Thread Local Storage (TLS) API
-   TLS API is DEPRECATED.  Use Thread Specific Storage (TSS) API.
-
-   The existing TLS API has used int to represent TLS keys across all
-   platforms, but it is not POSIX-compliant.  Therefore, the new TSS API uses
-   opaque data type to represent TSS keys to be compatible (see PEP 539).
-*/
-Py_DEPRECATED(3.7) PyAPI_FUNC(int) PyThread_create_key(void);
-Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_delete_key(int key);
-Py_DEPRECATED(3.7) PyAPI_FUNC(int) PyThread_set_key_value(int key,
-                                                          void *value);
-Py_DEPRECATED(3.7) PyAPI_FUNC(void *) PyThread_get_key_value(int key);
-Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_delete_key_value(int key);
-
-/* Cleanup after a fork */
-Py_DEPRECATED(3.7) PyAPI_FUNC(void) PyThread_ReInitTLS(void);
-
-
-#if !defined(Py_LIMITED_API) || Py_LIMITED_API+0 >= 0x03070000
-/* New in 3.7 */
-/* Thread Specific Storage (TSS) API */
-
-typedef struct _Py_tss_t Py_tss_t;  /* opaque */
-
-#ifndef Py_LIMITED_API
-#if defined(_POSIX_THREADS)
-    /* Darwin needs pthread.h to know type name the pthread_key_t. */
-#   include <pthread.h>
-#   define NATIVE_TSS_KEY_T     pthread_key_t
-#elif defined(NT_THREADS)
-    /* In Windows, native TSS key type is DWORD,
-       but hardcode the unsigned long to avoid errors for include directive.
-    */
-#   define NATIVE_TSS_KEY_T     unsigned long
-#else
-#   error "Require native threads. See https://bugs.python.org/issue31370"
-#endif
-
-/* When Py_LIMITED_API is not defined, the type layout of Py_tss_t is
-   exposed to allow static allocation in the API clients.  Even in this case,
-   you must handle TSS keys through API functions due to compatibility.
-*/
-struct _Py_tss_t {
-    int _is_initialized;
-    NATIVE_TSS_KEY_T _key;
-};
-
-#undef NATIVE_TSS_KEY_T
-
-/* When static allocation, you must initialize with Py_tss_NEEDS_INIT. */
-#define Py_tss_NEEDS_INIT   {0}
-#endif  /* !Py_LIMITED_API */
-
-PyAPI_FUNC(Py_tss_t *) PyThread_tss_alloc(void);
-PyAPI_FUNC(void) PyThread_tss_free(Py_tss_t *key);
-
-/* The parameter key must not be NULL. */
-PyAPI_FUNC(int) PyThread_tss_is_created(Py_tss_t *key);
-PyAPI_FUNC(int) PyThread_tss_create(Py_tss_t *key);
-PyAPI_FUNC(void) PyThread_tss_delete(Py_tss_t *key);
-PyAPI_FUNC(int) PyThread_tss_set(Py_tss_t *key, void *value);
-PyAPI_FUNC(void *) PyThread_tss_get(Py_tss_t *key);
-#endif  /* New in 3.7 */
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* !Py_PYTHREAD_H */