Estabilidade da API C
*********************

Python's C API is covered by the Backwards Compatibility Policy, **PEP
387**. While the C API will change with every minor release (e.g. from
3.9 to 3.10), most changes will be source-compatible, typically by
only adding new API. Changing existing API or removing API is only
done after a deprecation period or to fix serious issues.

A Interface Binário de Aplicação (ABI) do CPython é compatível para
frente e para trás através de uma versão menor (se elas forem
compiladas da mesma maneira; veja Considerações da plataforma abaixo).
Portanto, o código compilado para Python 3.10.0 funcionará em 3.10.8 e
vice-versa, mas precisará ser compilado separadamente para 3.9.x e
3.10.x.

Names prefixed by an underscore, such as "_Py_InternalState", are
private API that can change without notice even in patch releases.


Interface Binária de Aplicação Estável
======================================

Python 3.2 introduced the *Limited API*, a subset of Python's C API.
Extensions that only use the Limited API can be compiled once and work
with multiple versions of Python. Contents of the Limited API are
listed below.

To enable this, Python provides a *Stable ABI*: a set of symbols that
will remain compatible across Python 3.x versions. The Stable ABI
contains symbols exposed in the Limited API, but also other ones – for
example, functions necessary to support older versions of the Limited
API.

(For simplicity, this document talks about *extensions*, but the
Limited API and Stable ABI work the same way for all uses of the API –
for example, embedding Python.)

Py_LIMITED_API

   Defina essa macro antes de incluir "Python.h" para optar por usar
   apenas a API Limitada e selecionar a versão da API Limitada.

   Define "Py_LIMITED_API" to the value of "PY_VERSION_HEX"
   corresponding to the lowest Python version your extension supports.
   The extension will work without recompilation with all Python 3
   releases from the specified one onward, and can use Limited API
   introduced up to that version.

   Em vez de usar diretamente a macro "PY_VERSION_HEX", codifique uma
   versão menor mínima (por exemplo, "0x030A0000" para o Python 3.10)
   para garantir estabilidade ao compilar com versões futuras do
   Python.

   Você também pode definir "Py_LIMITED_API" como "3". Isso funciona
   da mesma forma que "0x03020000" (Python 3.2, a versão que
   introduziu a API Limitada).

No Windows, as extensões que usam a ABI Estável devem ser vinculadas a
"python3.dll" em vez de uma biblioteca específica de versão, como
"python39.dll".

Em algumas plataformas, o Python procurará e carregará arquivos de
biblioteca compartilhada com o nome marcado como "abi3" (por exemplo,
"meumódulo.abi3.so"). Ele não verifica se essas extensões estão em
conformidade com uma ABI Estável. O usuário (ou suas ferramentas de
empacotamento) precisa garantir que, por exemplo, as extensões
construídas com a API Limitada 3.10+ não sejam instaladas em versões
mais baixas do Python.

Todas as funções na ABI estável estão presentes como funções na
biblioteca compartilhada do Python, não apenas como macros. Isso as
torna utilizáveis em linguagens que não utilizam o pré-processador C.


Escopo e Desempenho da API Limitada
-----------------------------------

O objetivo da API Limitada é permitir tudo o que é possível com a API
C completa, mas possivelmente com uma penalidade de desempenho.

Por exemplo, enquanto "PyList_GetItem()" está disponível, sua variante
de macro "insegura" "PyList_GET_ITEM()" não está. A macro pode ser
mais rápida porque pode depender de detalhes de implementação
específicos da versão do objeto da lista.

Sem a definição de "Py_LIMITED_API", algumas funções da API C são
colocadas "inline" ou substituídas por macros. Definir
"Py_LIMITED_API" desativa esse inline, permitindo estabilidade à
medida que as estruturas de dados do Python são aprimoradas, mas
possivelmente reduzindo o desempenho.

Ao deixar de fora a definição "Py_LIMITED_API", é possível compilar
uma extensão da API Limitada com uma ABI específica da versão. Isso
pode melhorar o desempenho para essa versão do Python, mas limitará a
compatibilidade. Compilar com "Py_LIMITED_API" vai produzir uma
extensão que pode ser distribuída quando uma específica da versão não
estiver disponível -- por exemplo, para pré-lançamentos de uma próxima
versão do Python.


Limitações da API Limitada
--------------------------

Note that compiling with "Py_LIMITED_API" is *not* a complete
guarantee that code conforms to the Limited API or the Stable ABI.
"Py_LIMITED_API" only covers definitions, but an API also includes
other issues, such as expected semantics.

Uma questão que "Py_LIMITED_API" não protege é a chamada de uma função
com argumentos inválidos em uma versão inferior do Python. Por
exemplo, considere uma função que começa a aceitar "NULL" como
argumento. No Python 3.9, "NULL" agora seleciona um comportamento
padrão, mas no Python 3.8, o argumento será usado diretamente,
causando uma referência "NULL" e uma falha. Um argumento similar
funciona para campos de estruturas.

Outra questão é que alguns campos de estrutura não estão atualmente
ocultos quando "Py_LIMITED_API" é definido, mesmo que eles façam parte
da API Limitada.

Por esses motivos, recomendamos testar uma extensão com *todas* as
versões menores do Python que ela oferece suporte e,
preferencialmente, construir com a versão *mais baixa* dessas.

Também recomendamos revisar a documentação de todas as APIs utilizadas
para verificar se ela faz parte explicitamente da API Limitada. Mesmo
com a definição de "Py_LIMITED_API", algumas declarações privadas são
expostas por razões técnicas (ou até mesmo acidentalmente, como bugs).

Também observe que a API Limitada não é necessariamente estável:
compilar com "Py_LIMITED_API" com Python 3.8 significa que a extensão
será executada com Python 3.12, mas não necessariamente será
*compilada* com Python 3.12. Em particular, partes da API Limitada
podem ser descontinuadas e removidas, desde que a ABI Estável
permaneça estável.


Considerações da plataforma
===========================

ABI stability depends not only on Python, but also on the compiler
used, lower-level libraries and compiler options. For the purposes of
the Stable ABI, these details define a “platform”. They usually depend
on the OS type and processor architecture

É responsabilidade de cada distribuidor particular do Python garantir
que todas as versões do Python em uma plataforma específica sejam
construídas de forma a não quebrar a ABI estável. Isso é válido para
as versões do Windows e macOS disponibilizadas pela "python.org" e por
muitos distribuidores terceiros.


Conteúdo da API Limitada
========================

Currently, the Limited API includes the following items:

* "PyAIter_Check()"

* "PyArg_Parse()"

* "PyArg_ParseTuple()"

* "PyArg_ParseTupleAndKeywords()"

* "PyArg_UnpackTuple()"

* "PyArg_VaParse()"

* "PyArg_VaParseTupleAndKeywords()"

* "PyArg_ValidateKeywordArguments()"

* "PyBaseObject_Type"

* "PyBool_FromLong()"

* "PyBool_Type"

* "PyByteArrayIter_Type"

* "PyByteArray_AsString()"

* "PyByteArray_Concat()"

* "PyByteArray_FromObject()"

* "PyByteArray_FromStringAndSize()"

* "PyByteArray_Resize()"

* "PyByteArray_Size()"

* "PyByteArray_Type"

* "PyBytesIter_Type"

* "PyBytes_AsString()"

* "PyBytes_AsStringAndSize()"

* "PyBytes_Concat()"

* "PyBytes_ConcatAndDel()"

* "PyBytes_DecodeEscape()"

* "PyBytes_FromFormat()"

* "PyBytes_FromFormatV()"

* "PyBytes_FromObject()"

* "PyBytes_FromString()"

* "PyBytes_FromStringAndSize()"

* "PyBytes_Repr()"

* "PyBytes_Size()"

* "PyBytes_Type"

* "PyCFunction"

* "PyCFunctionWithKeywords"

* "PyCFunction_Call()"

* "PyCFunction_GetFlags()"

* "PyCFunction_GetFunction()"

* "PyCFunction_GetSelf()"

* "PyCFunction_New()"

* "PyCFunction_NewEx()"

* "PyCFunction_Type"

* "PyCMethod_New()"

* "PyCallIter_New()"

* "PyCallIter_Type"

* "PyCallable_Check()"

* "PyCapsule_Destructor"

* "PyCapsule_GetContext()"

* "PyCapsule_GetDestructor()"

* "PyCapsule_GetName()"

* "PyCapsule_GetPointer()"

* "PyCapsule_Import()"

* "PyCapsule_IsValid()"

* "PyCapsule_New()"

* "PyCapsule_SetContext()"

* "PyCapsule_SetDestructor()"

* "PyCapsule_SetName()"

* "PyCapsule_SetPointer()"

* "PyCapsule_Type"

* "PyClassMethodDescr_Type"

* "PyCodec_BackslashReplaceErrors()"

* "PyCodec_Decode()"

* "PyCodec_Decoder()"

* "PyCodec_Encode()"

* "PyCodec_Encoder()"

* "PyCodec_IgnoreErrors()"

* "PyCodec_IncrementalDecoder()"

* "PyCodec_IncrementalEncoder()"

* "PyCodec_KnownEncoding()"

* "PyCodec_LookupError()"

* "PyCodec_NameReplaceErrors()"

* "PyCodec_Register()"

* "PyCodec_RegisterError()"

* "PyCodec_ReplaceErrors()"

* "PyCodec_StreamReader()"

* "PyCodec_StreamWriter()"

* "PyCodec_StrictErrors()"

* "PyCodec_Unregister()"

* "PyCodec_XMLCharRefReplaceErrors()"

* "PyComplex_FromDoubles()"

* "PyComplex_ImagAsDouble()"

* "PyComplex_RealAsDouble()"

* "PyComplex_Type"

* "PyDescr_NewClassMethod()"

* "PyDescr_NewGetSet()"

* "PyDescr_NewMember()"

* "PyDescr_NewMethod()"

* "PyDictItems_Type"

* "PyDictIterItem_Type"

* "PyDictIterKey_Type"

* "PyDictIterValue_Type"

* "PyDictKeys_Type"

* "PyDictProxy_New()"

* "PyDictProxy_Type"

* "PyDictRevIterItem_Type"

* "PyDictRevIterKey_Type"

* "PyDictRevIterValue_Type"

* "PyDictValues_Type"

* "PyDict_Clear()"

* "PyDict_Contains()"

* "PyDict_Copy()"

* "PyDict_DelItem()"

* "PyDict_DelItemString()"

* "PyDict_GetItem()"

* "PyDict_GetItemString()"

* "PyDict_GetItemWithError()"

* "PyDict_Items()"

* "PyDict_Keys()"

* "PyDict_Merge()"

* "PyDict_MergeFromSeq2()"

* "PyDict_New()"

* "PyDict_Next()"

* "PyDict_SetItem()"

* "PyDict_SetItemString()"

* "PyDict_Size()"

* "PyDict_Type"

* "PyDict_Update()"

* "PyDict_Values()"

* "PyEllipsis_Type"

* "PyEnum_Type"

* "PyErr_BadArgument()"

* "PyErr_BadInternalCall()"

* "PyErr_CheckSignals()"

* "PyErr_Clear()"

* "PyErr_Display()"

* "PyErr_ExceptionMatches()"

* "PyErr_Fetch()"

* "PyErr_Format()"

* "PyErr_FormatV()"

* "PyErr_GetExcInfo()"

* "PyErr_GivenExceptionMatches()"

* "PyErr_NewException()"

* "PyErr_NewExceptionWithDoc()"

* "PyErr_NoMemory()"

* "PyErr_NormalizeException()"

* "PyErr_Occurred()"

* "PyErr_Print()"

* "PyErr_PrintEx()"

* "PyErr_ProgramText()"

* "PyErr_ResourceWarning()"

* "PyErr_Restore()"

* "PyErr_SetExcFromWindowsErr()"

* "PyErr_SetExcFromWindowsErrWithFilename()"

* "PyErr_SetExcFromWindowsErrWithFilenameObject()"

* "PyErr_SetExcFromWindowsErrWithFilenameObjects()"

* "PyErr_SetExcInfo()"

* "PyErr_SetFromErrno()"

* "PyErr_SetFromErrnoWithFilename()"

* "PyErr_SetFromErrnoWithFilenameObject()"

* "PyErr_SetFromErrnoWithFilenameObjects()"

* "PyErr_SetFromWindowsErr()"

* "PyErr_SetFromWindowsErrWithFilename()"

* "PyErr_SetImportError()"

* "PyErr_SetImportErrorSubclass()"

* "PyErr_SetInterrupt()"

* "PyErr_SetInterruptEx()"

* "PyErr_SetNone()"

* "PyErr_SetObject()"

* "PyErr_SetString()"

* "PyErr_SyntaxLocation()"

* "PyErr_SyntaxLocationEx()"

* "PyErr_WarnEx()"

* "PyErr_WarnExplicit()"

* "PyErr_WarnFormat()"

* "PyErr_WriteUnraisable()"

* "PyEval_AcquireLock()"

* "PyEval_AcquireThread()"

* "PyEval_CallFunction()"

* "PyEval_CallMethod()"

* "PyEval_CallObjectWithKeywords()"

* "PyEval_EvalCode()"

* "PyEval_EvalCodeEx()"

* "PyEval_EvalFrame()"

* "PyEval_EvalFrameEx()"

* "PyEval_GetBuiltins()"

* "PyEval_GetFrame()"

* "PyEval_GetFuncDesc()"

* "PyEval_GetFuncName()"

* "PyEval_GetGlobals()"

* "PyEval_GetLocals()"

* "PyEval_InitThreads()"

* "PyEval_ReleaseLock()"

* "PyEval_ReleaseThread()"

* "PyEval_RestoreThread()"

* "PyEval_SaveThread()"

* "PyEval_ThreadsInitialized()"

* "PyExc_ArithmeticError"

* "PyExc_AssertionError"

* "PyExc_AttributeError"

* "PyExc_BaseException"

* "PyExc_BlockingIOError"

* "PyExc_BrokenPipeError"

* "PyExc_BufferError"

* "PyExc_BytesWarning"

* "PyExc_ChildProcessError"

* "PyExc_ConnectionAbortedError"

* "PyExc_ConnectionError"

* "PyExc_ConnectionRefusedError"

* "PyExc_ConnectionResetError"

* "PyExc_DeprecationWarning"

* "PyExc_EOFError"

* "PyExc_EncodingWarning"

* "PyExc_EnvironmentError"

* "PyExc_Exception"

* "PyExc_FileExistsError"

* "PyExc_FileNotFoundError"

* "PyExc_FloatingPointError"

* "PyExc_FutureWarning"

* "PyExc_GeneratorExit"

* "PyExc_IOError"

* "PyExc_ImportError"

* "PyExc_ImportWarning"

* "PyExc_IndentationError"

* "PyExc_IndexError"

* "PyExc_InterruptedError"

* "PyExc_IsADirectoryError"

* "PyExc_KeyError"

* "PyExc_KeyboardInterrupt"

* "PyExc_LookupError"

* "PyExc_MemoryError"

* "PyExc_ModuleNotFoundError"

* "PyExc_NameError"

* "PyExc_NotADirectoryError"

* "PyExc_NotImplementedError"

* "PyExc_OSError"

* "PyExc_OverflowError"

* "PyExc_PendingDeprecationWarning"

* "PyExc_PermissionError"

* "PyExc_ProcessLookupError"

* "PyExc_RecursionError"

* "PyExc_ReferenceError"

* "PyExc_ResourceWarning"

* "PyExc_RuntimeError"

* "PyExc_RuntimeWarning"

* "PyExc_StopAsyncIteration"

* "PyExc_StopIteration"

* "PyExc_SyntaxError"

* "PyExc_SyntaxWarning"

* "PyExc_SystemError"

* "PyExc_SystemExit"

* "PyExc_TabError"

* "PyExc_TimeoutError"

* "PyExc_TypeError"

* "PyExc_UnboundLocalError"

* "PyExc_UnicodeDecodeError"

* "PyExc_UnicodeEncodeError"

* "PyExc_UnicodeError"

* "PyExc_UnicodeTranslateError"

* "PyExc_UnicodeWarning"

* "PyExc_UserWarning"

* "PyExc_ValueError"

* "PyExc_Warning"

* "PyExc_WindowsError"

* "PyExc_ZeroDivisionError"

* "PyExceptionClass_Name()"

* "PyException_GetCause()"

* "PyException_GetContext()"

* "PyException_GetTraceback()"

* "PyException_SetCause()"

* "PyException_SetContext()"

* "PyException_SetTraceback()"

* "PyFile_FromFd()"

* "PyFile_GetLine()"

* "PyFile_WriteObject()"

* "PyFile_WriteString()"

* "PyFilter_Type"

* "PyFloat_AsDouble()"

* "PyFloat_FromDouble()"

* "PyFloat_FromString()"

* "PyFloat_GetInfo()"

* "PyFloat_GetMax()"

* "PyFloat_GetMin()"

* "PyFloat_Type"

* "PyFrameObject"

* "PyFrame_GetCode()"

* "PyFrame_GetLineNumber()"

* "PyFrozenSet_New()"

* "PyFrozenSet_Type"

* "PyGC_Collect()"

* "PyGC_Disable()"

* "PyGC_Enable()"

* "PyGC_IsEnabled()"

* "PyGILState_Ensure()"

* "PyGILState_GetThisThreadState()"

* "PyGILState_Release()"

* "PyGILState_STATE"

* "PyGetSetDef"

* "PyGetSetDescr_Type"

* "PyImport_AddModule()"

* "PyImport_AddModuleObject()"

* "PyImport_AppendInittab()"

* "PyImport_ExecCodeModule()"

* "PyImport_ExecCodeModuleEx()"

* "PyImport_ExecCodeModuleObject()"

* "PyImport_ExecCodeModuleWithPathnames()"

* "PyImport_GetImporter()"

* "PyImport_GetMagicNumber()"

* "PyImport_GetMagicTag()"

* "PyImport_GetModule()"

* "PyImport_GetModuleDict()"

* "PyImport_Import()"

* "PyImport_ImportFrozenModule()"

* "PyImport_ImportFrozenModuleObject()"

* "PyImport_ImportModule()"

* "PyImport_ImportModuleLevel()"

* "PyImport_ImportModuleLevelObject()"

* "PyImport_ImportModuleNoBlock()"

* "PyImport_ReloadModule()"

* "PyIndex_Check()"

* "PyInterpreterState"

* "PyInterpreterState_Clear()"

* "PyInterpreterState_Delete()"

* "PyInterpreterState_Get()"

* "PyInterpreterState_GetDict()"

* "PyInterpreterState_GetID()"

* "PyInterpreterState_New()"

* "PyIter_Check()"

* "PyIter_Next()"

* "PyIter_Send()"

* "PyListIter_Type"

* "PyListRevIter_Type"

* "PyList_Append()"

* "PyList_AsTuple()"

* "PyList_GetItem()"

* "PyList_GetSlice()"

* "PyList_Insert()"

* "PyList_New()"

* "PyList_Reverse()"

* "PyList_SetItem()"

* "PyList_SetSlice()"

* "PyList_Size()"

* "PyList_Sort()"

* "PyList_Type"

* "PyLongObject"

* "PyLongRangeIter_Type"

* "PyLong_AsDouble()"

* "PyLong_AsLong()"

* "PyLong_AsLongAndOverflow()"

* "PyLong_AsLongLong()"

* "PyLong_AsLongLongAndOverflow()"

* "PyLong_AsSize_t()"

* "PyLong_AsSsize_t()"

* "PyLong_AsUnsignedLong()"

* "PyLong_AsUnsignedLongLong()"

* "PyLong_AsUnsignedLongLongMask()"

* "PyLong_AsUnsignedLongMask()"

* "PyLong_AsVoidPtr()"

* "PyLong_FromDouble()"

* "PyLong_FromLong()"

* "PyLong_FromLongLong()"

* "PyLong_FromSize_t()"

* "PyLong_FromSsize_t()"

* "PyLong_FromString()"

* "PyLong_FromUnsignedLong()"

* "PyLong_FromUnsignedLongLong()"

* "PyLong_FromVoidPtr()"

* "PyLong_GetInfo()"

* "PyLong_Type"

* "PyMap_Type"

* "PyMapping_Check()"

* "PyMapping_GetItemString()"

* "PyMapping_HasKey()"

* "PyMapping_HasKeyString()"

* "PyMapping_Items()"

* "PyMapping_Keys()"

* "PyMapping_Length()"

* "PyMapping_SetItemString()"

* "PyMapping_Size()"

* "PyMapping_Values()"

* "PyMem_Calloc()"

* "PyMem_Free()"

* "PyMem_Malloc()"

* "PyMem_Realloc()"

* "PyMemberDef"

* "PyMemberDescr_Type"

* "PyMemoryView_FromMemory()"

* "PyMemoryView_FromObject()"

* "PyMemoryView_GetContiguous()"

* "PyMemoryView_Type"

* "PyMethodDef"

* "PyMethodDescr_Type"

* "PyModuleDef"

* "PyModuleDef_Base"

* "PyModuleDef_Init()"

* "PyModuleDef_Type"

* "PyModule_AddFunctions()"

* "PyModule_AddIntConstant()"

* "PyModule_AddObject()"

* "PyModule_AddObjectRef()"

* "PyModule_AddStringConstant()"

* "PyModule_AddType()"

* "PyModule_Create2()"

* "PyModule_ExecDef()"

* "PyModule_FromDefAndSpec2()"

* "PyModule_GetDef()"

* "PyModule_GetDict()"

* "PyModule_GetFilename()"

* "PyModule_GetFilenameObject()"

* "PyModule_GetName()"

* "PyModule_GetNameObject()"

* "PyModule_GetState()"

* "PyModule_New()"

* "PyModule_NewObject()"

* "PyModule_SetDocString()"

* "PyModule_Type"

* "PyNumber_Absolute()"

* "PyNumber_Add()"

* "PyNumber_And()"

* "PyNumber_AsSsize_t()"

* "PyNumber_Check()"

* "PyNumber_Divmod()"

* "PyNumber_Float()"

* "PyNumber_FloorDivide()"

* "PyNumber_InPlaceAdd()"

* "PyNumber_InPlaceAnd()"

* "PyNumber_InPlaceFloorDivide()"

* "PyNumber_InPlaceLshift()"

* "PyNumber_InPlaceMatrixMultiply()"

* "PyNumber_InPlaceMultiply()"

* "PyNumber_InPlaceOr()"

* "PyNumber_InPlacePower()"

* "PyNumber_InPlaceRemainder()"

* "PyNumber_InPlaceRshift()"

* "PyNumber_InPlaceSubtract()"

* "PyNumber_InPlaceTrueDivide()"

* "PyNumber_InPlaceXor()"

* "PyNumber_Index()"

* "PyNumber_Invert()"

* "PyNumber_Long()"

* "PyNumber_Lshift()"

* "PyNumber_MatrixMultiply()"

* "PyNumber_Multiply()"

* "PyNumber_Negative()"

* "PyNumber_Or()"

* "PyNumber_Positive()"

* "PyNumber_Power()"

* "PyNumber_Remainder()"

* "PyNumber_Rshift()"

* "PyNumber_Subtract()"

* "PyNumber_ToBase()"

* "PyNumber_TrueDivide()"

* "PyNumber_Xor()"

* "PyOS_AfterFork()"

* "PyOS_AfterFork_Child()"

* "PyOS_AfterFork_Parent()"

* "PyOS_BeforeFork()"

* "PyOS_CheckStack()"

* "PyOS_FSPath()"

* "PyOS_InputHook"

* "PyOS_InterruptOccurred()"

* "PyOS_double_to_string()"

* "PyOS_getsig()"

* "PyOS_mystricmp()"

* "PyOS_mystrnicmp()"

* "PyOS_setsig()"

* "PyOS_sighandler_t"

* "PyOS_snprintf()"

* "PyOS_string_to_double()"

* "PyOS_strtol()"

* "PyOS_strtoul()"

* "PyOS_vsnprintf()"

* "PyObject"

* "PyObject.ob_refcnt"

* "PyObject.ob_type"

* "PyObject_ASCII()"

* "PyObject_AsCharBuffer()"

* "PyObject_AsFileDescriptor()"

* "PyObject_AsReadBuffer()"

* "PyObject_AsWriteBuffer()"

* "PyObject_Bytes()"

* "PyObject_Call()"

* "PyObject_CallFunction()"

* "PyObject_CallFunctionObjArgs()"

* "PyObject_CallMethod()"

* "PyObject_CallMethodObjArgs()"

* "PyObject_CallNoArgs()"

* "PyObject_CallObject()"

* "PyObject_Calloc()"

* "PyObject_CheckReadBuffer()"

* "PyObject_ClearWeakRefs()"

* "PyObject_DelItem()"

* "PyObject_DelItemString()"

* "PyObject_Dir()"

* "PyObject_Format()"

* "PyObject_Free()"

* "PyObject_GC_Del()"

* "PyObject_GC_IsFinalized()"

* "PyObject_GC_IsTracked()"

* "PyObject_GC_Track()"

* "PyObject_GC_UnTrack()"

* "PyObject_GenericGetAttr()"

* "PyObject_GenericGetDict()"

* "PyObject_GenericSetAttr()"

* "PyObject_GenericSetDict()"

* "PyObject_GetAIter()"

* "PyObject_GetAttr()"

* "PyObject_GetAttrString()"

* "PyObject_GetItem()"

* "PyObject_GetIter()"

* "PyObject_HasAttr()"

* "PyObject_HasAttrString()"

* "PyObject_Hash()"

* "PyObject_HashNotImplemented()"

* "PyObject_Init()"

* "PyObject_InitVar()"

* "PyObject_IsInstance()"

* "PyObject_IsSubclass()"

* "PyObject_IsTrue()"

* "PyObject_Length()"

* "PyObject_Malloc()"

* "PyObject_Not()"

* "PyObject_Realloc()"

* "PyObject_Repr()"

* "PyObject_RichCompare()"

* "PyObject_RichCompareBool()"

* "PyObject_SelfIter()"

* "PyObject_SetAttr()"

* "PyObject_SetAttrString()"

* "PyObject_SetItem()"

* "PyObject_Size()"

* "PyObject_Str()"

* "PyObject_Type()"

* "PyProperty_Type"

* "PyRangeIter_Type"

* "PyRange_Type"

* "PyReversed_Type"

* "PySeqIter_New()"

* "PySeqIter_Type"

* "PySequence_Check()"

* "PySequence_Concat()"

* "PySequence_Contains()"

* "PySequence_Count()"

* "PySequence_DelItem()"

* "PySequence_DelSlice()"

* "PySequence_Fast()"

* "PySequence_GetItem()"

* "PySequence_GetSlice()"

* "PySequence_In()"

* "PySequence_InPlaceConcat()"

* "PySequence_InPlaceRepeat()"

* "PySequence_Index()"

* "PySequence_Length()"

* "PySequence_List()"

* "PySequence_Repeat()"

* "PySequence_SetItem()"

* "PySequence_SetSlice()"

* "PySequence_Size()"

* "PySequence_Tuple()"

* "PySetIter_Type"

* "PySet_Add()"

* "PySet_Clear()"

* "PySet_Contains()"

* "PySet_Discard()"

* "PySet_New()"

* "PySet_Pop()"

* "PySet_Size()"

* "PySet_Type"

* "PySlice_AdjustIndices()"

* "PySlice_GetIndices()"

* "PySlice_GetIndicesEx()"

* "PySlice_New()"

* "PySlice_Type"

* "PySlice_Unpack()"

* "PyState_AddModule()"

* "PyState_FindModule()"

* "PyState_RemoveModule()"

* "PyStructSequence_Desc"

* "PyStructSequence_Field"

* "PyStructSequence_GetItem()"

* "PyStructSequence_New()"

* "PyStructSequence_NewType()"

* "PyStructSequence_SetItem()"

* "PySuper_Type"

* "PySys_AddWarnOption()"

* "PySys_AddWarnOptionUnicode()"

* "PySys_AddXOption()"

* "PySys_FormatStderr()"

* "PySys_FormatStdout()"

* "PySys_GetObject()"

* "PySys_GetXOptions()"

* "PySys_HasWarnOptions()"

* "PySys_ResetWarnOptions()"

* "PySys_SetArgv()"

* "PySys_SetArgvEx()"

* "PySys_SetObject()"

* "PySys_SetPath()"

* "PySys_WriteStderr()"

* "PySys_WriteStdout()"

* "PyThreadState"

* "PyThreadState_Clear()"

* "PyThreadState_Delete()"

* "PyThreadState_Get()"

* "PyThreadState_GetDict()"

* "PyThreadState_GetFrame()"

* "PyThreadState_GetID()"

* "PyThreadState_GetInterpreter()"

* "PyThreadState_New()"

* "PyThreadState_SetAsyncExc()"

* "PyThreadState_Swap()"

* "PyThread_GetInfo()"

* "PyThread_ReInitTLS()"

* "PyThread_acquire_lock()"

* "PyThread_acquire_lock_timed()"

* "PyThread_allocate_lock()"

* "PyThread_create_key()"

* "PyThread_delete_key()"

* "PyThread_delete_key_value()"

* "PyThread_exit_thread()"

* "PyThread_free_lock()"

* "PyThread_get_key_value()"

* "PyThread_get_stacksize()"

* "PyThread_get_thread_ident()"

* "PyThread_get_thread_native_id()"

* "PyThread_init_thread()"

* "PyThread_release_lock()"

* "PyThread_set_key_value()"

* "PyThread_set_stacksize()"

* "PyThread_start_new_thread()"

* "PyThread_tss_alloc()"

* "PyThread_tss_create()"

* "PyThread_tss_delete()"

* "PyThread_tss_free()"

* "PyThread_tss_get()"

* "PyThread_tss_is_created()"

* "PyThread_tss_set()"

* "PyTraceBack_Here()"

* "PyTraceBack_Print()"

* "PyTraceBack_Type"

* "PyTupleIter_Type"

* "PyTuple_GetItem()"

* "PyTuple_GetSlice()"

* "PyTuple_New()"

* "PyTuple_Pack()"

* "PyTuple_SetItem()"

* "PyTuple_Size()"

* "PyTuple_Type"

* "PyTypeObject"

* "PyType_ClearCache()"

* "PyType_FromModuleAndSpec()"

* "PyType_FromSpec()"

* "PyType_FromSpecWithBases()"

* "PyType_GenericAlloc()"

* "PyType_GenericNew()"

* "PyType_GetFlags()"

* "PyType_GetModule()"

* "PyType_GetModuleState()"

* "PyType_GetSlot()"

* "PyType_IsSubtype()"

* "PyType_Modified()"

* "PyType_Ready()"

* "PyType_Slot"

* "PyType_Spec"

* "PyType_Type"

* "PyUnicodeDecodeError_Create()"

* "PyUnicodeDecodeError_GetEncoding()"

* "PyUnicodeDecodeError_GetEnd()"

* "PyUnicodeDecodeError_GetObject()"

* "PyUnicodeDecodeError_GetReason()"

* "PyUnicodeDecodeError_GetStart()"

* "PyUnicodeDecodeError_SetEnd()"

* "PyUnicodeDecodeError_SetReason()"

* "PyUnicodeDecodeError_SetStart()"

* "PyUnicodeEncodeError_GetEncoding()"

* "PyUnicodeEncodeError_GetEnd()"

* "PyUnicodeEncodeError_GetObject()"

* "PyUnicodeEncodeError_GetReason()"

* "PyUnicodeEncodeError_GetStart()"

* "PyUnicodeEncodeError_SetEnd()"

* "PyUnicodeEncodeError_SetReason()"

* "PyUnicodeEncodeError_SetStart()"

* "PyUnicodeIter_Type"

* "PyUnicodeTranslateError_GetEnd()"

* "PyUnicodeTranslateError_GetObject()"

* "PyUnicodeTranslateError_GetReason()"

* "PyUnicodeTranslateError_GetStart()"

* "PyUnicodeTranslateError_SetEnd()"

* "PyUnicodeTranslateError_SetReason()"

* "PyUnicodeTranslateError_SetStart()"

* "PyUnicode_Append()"

* "PyUnicode_AppendAndDel()"

* "PyUnicode_AsASCIIString()"

* "PyUnicode_AsCharmapString()"

* "PyUnicode_AsDecodedObject()"

* "PyUnicode_AsDecodedUnicode()"

* "PyUnicode_AsEncodedObject()"

* "PyUnicode_AsEncodedString()"

* "PyUnicode_AsEncodedUnicode()"

* "PyUnicode_AsLatin1String()"

* "PyUnicode_AsMBCSString()"

* "PyUnicode_AsRawUnicodeEscapeString()"

* "PyUnicode_AsUCS4()"

* "PyUnicode_AsUCS4Copy()"

* "PyUnicode_AsUTF16String()"

* "PyUnicode_AsUTF32String()"

* "PyUnicode_AsUTF8AndSize()"

* "PyUnicode_AsUTF8String()"

* "PyUnicode_AsUnicodeEscapeString()"

* "PyUnicode_AsWideChar()"

* "PyUnicode_AsWideCharString()"

* "PyUnicode_BuildEncodingMap()"

* "PyUnicode_Compare()"

* "PyUnicode_CompareWithASCIIString()"

* "PyUnicode_Concat()"

* "PyUnicode_Contains()"

* "PyUnicode_Count()"

* "PyUnicode_Decode()"

* "PyUnicode_DecodeASCII()"

* "PyUnicode_DecodeCharmap()"

* "PyUnicode_DecodeCodePageStateful()"

* "PyUnicode_DecodeFSDefault()"

* "PyUnicode_DecodeFSDefaultAndSize()"

* "PyUnicode_DecodeLatin1()"

* "PyUnicode_DecodeLocale()"

* "PyUnicode_DecodeLocaleAndSize()"

* "PyUnicode_DecodeMBCS()"

* "PyUnicode_DecodeMBCSStateful()"

* "PyUnicode_DecodeRawUnicodeEscape()"

* "PyUnicode_DecodeUTF16()"

* "PyUnicode_DecodeUTF16Stateful()"

* "PyUnicode_DecodeUTF32()"

* "PyUnicode_DecodeUTF32Stateful()"

* "PyUnicode_DecodeUTF7()"

* "PyUnicode_DecodeUTF7Stateful()"

* "PyUnicode_DecodeUTF8()"

* "PyUnicode_DecodeUTF8Stateful()"

* "PyUnicode_DecodeUnicodeEscape()"

* "PyUnicode_EncodeCodePage()"

* "PyUnicode_EncodeFSDefault()"

* "PyUnicode_EncodeLocale()"

* "PyUnicode_FSConverter()"

* "PyUnicode_FSDecoder()"

* "PyUnicode_Find()"

* "PyUnicode_FindChar()"

* "PyUnicode_Format()"

* "PyUnicode_FromEncodedObject()"

* "PyUnicode_FromFormat()"

* "PyUnicode_FromFormatV()"

* "PyUnicode_FromObject()"

* "PyUnicode_FromOrdinal()"

* "PyUnicode_FromString()"

* "PyUnicode_FromStringAndSize()"

* "PyUnicode_FromWideChar()"

* "PyUnicode_GetDefaultEncoding()"

* "PyUnicode_GetLength()"

* "PyUnicode_GetSize()"

* "PyUnicode_InternFromString()"

* "PyUnicode_InternImmortal()"

* "PyUnicode_InternInPlace()"

* "PyUnicode_IsIdentifier()"

* "PyUnicode_Join()"

* "PyUnicode_Partition()"

* "PyUnicode_RPartition()"

* "PyUnicode_RSplit()"

* "PyUnicode_ReadChar()"

* "PyUnicode_Replace()"

* "PyUnicode_Resize()"

* "PyUnicode_RichCompare()"

* "PyUnicode_Split()"

* "PyUnicode_Splitlines()"

* "PyUnicode_Substring()"

* "PyUnicode_Tailmatch()"

* "PyUnicode_Translate()"

* "PyUnicode_Type"

* "PyUnicode_WriteChar()"

* "PyVarObject"

* "PyVarObject.ob_base"

* "PyVarObject.ob_size"

* "PyWeakReference"

* "PyWeakref_GetObject()"

* "PyWeakref_NewProxy()"

* "PyWeakref_NewRef()"

* "PyWrapperDescr_Type"

* "PyWrapper_New()"

* "PyZip_Type"

* "Py_AddPendingCall()"

* "Py_AtExit()"

* "Py_BEGIN_ALLOW_THREADS"

* "Py_BLOCK_THREADS"

* "Py_BuildValue()"

* "Py_BytesMain()"

* "Py_CompileString()"

* "Py_DecRef()"

* "Py_DecodeLocale()"

* "Py_END_ALLOW_THREADS"

* "Py_EncodeLocale()"

* "Py_EndInterpreter()"

* "Py_EnterRecursiveCall()"

* "Py_Exit()"

* "Py_FatalError()"

* "Py_FileSystemDefaultEncodeErrors"

* "Py_FileSystemDefaultEncoding"

* "Py_Finalize()"

* "Py_FinalizeEx()"

* "Py_GenericAlias()"

* "Py_GenericAliasType"

* "Py_GetBuildInfo()"

* "Py_GetCompiler()"

* "Py_GetCopyright()"

* "Py_GetExecPrefix()"

* "Py_GetPath()"

* "Py_GetPlatform()"

* "Py_GetPrefix()"

* "Py_GetProgramFullPath()"

* "Py_GetProgramName()"

* "Py_GetPythonHome()"

* "Py_GetRecursionLimit()"

* "Py_GetVersion()"

* "Py_HasFileSystemDefaultEncoding"

* "Py_IncRef()"

* "Py_Initialize()"

* "Py_InitializeEx()"

* "Py_Is()"

* "Py_IsFalse()"

* "Py_IsInitialized()"

* "Py_IsNone()"

* "Py_IsTrue()"

* "Py_LeaveRecursiveCall()"

* "Py_Main()"

* "Py_MakePendingCalls()"

* "Py_NewInterpreter()"

* "Py_NewRef()"

* "Py_ReprEnter()"

* "Py_ReprLeave()"

* "Py_SetPath()"

* "Py_SetProgramName()"

* "Py_SetPythonHome()"

* "Py_SetRecursionLimit()"

* "Py_UCS4"

* "Py_UNBLOCK_THREADS"

* "Py_UTF8Mode"

* "Py_VaBuildValue()"

* "Py_XNewRef()"

* "Py_intptr_t"

* "Py_ssize_t"

* "Py_uintptr_t"

* "allocfunc"

* "binaryfunc"

* "descrgetfunc"

* "descrsetfunc"

* "destructor"

* "getattrfunc"

* "getattrofunc"

* "getiterfunc"

* "getter"

* "hashfunc"

* "initproc"

* "inquiry"

* "iternextfunc"

* "lenfunc"

* "newfunc"

* "objobjargproc"

* "objobjproc"

* "reprfunc"

* "richcmpfunc"

* "setattrfunc"

* "setattrofunc"

* "setter"

* "ssizeargfunc"

* "ssizeobjargproc"

* "ssizessizeargfunc"

* "ssizessizeobjargproc"

* "symtable"

* "ternaryfunc"

* "traverseproc"

* "unaryfunc"

* "visitproc"
