Objetos tipo
************

PyTypeObject

   A estrutura C dos objetos usados para descrever tipos embutidos.

PyTypeObject PyType_Type

   Este é o objeto de tipo para objetos tipo; é o mesmo objeto que
   "type" na camada Python.

int PyType_Check(PyObject *o)

   Retorna valor diferente de zero se o objeto *o* for um objeto tipo,
   incluindo instâncias de tipos derivados do objeto tipo padrão.
   Retorna 0 em todos os outros casos. Esta função sempre tem sucesso.

int PyType_CheckExact(PyObject *o)

   Retorna valor diferente de zero se o objeto *o* for um objeto tipo,
   mas não um subtipo do objeto tipo padrão. Retorna 0 em todos os
   outros casos. Esta função sempre tem sucesso.

unsigned int PyType_ClearCache()

   Limpa o cache de pesquisa interno. Retorna a marcação de versão
   atual.

unsigned long PyType_GetFlags(PyTypeObject* type)

   Retorna o membro "tp_flags" de *type*. Esta função deve ser usada
   principalmente com *Py_LIMITED_API*; os bits sinalizadores
   individuais têm garantia de estabilidade em todas as versões do
   Python, mas o acesso a "tp_flags" não faz parte da API limitada.

   Novo na versão 3.2.

   Alterado na versão 3.4: O tipo de retorno é agora um "unsigned
   long" em vez de um "long".

void PyType_Modified(PyTypeObject *type)

   Invalida o cache de pesquisa interna para o tipo e todos os seus
   subtipos. Esta função deve ser chamada após qualquer modificação
   manual dos atributos ou classes bases do tipo.

int PyType_HasFeature(PyTypeObject *o, int feature)

   Retorna valor diferente de zero se o objeto tipo *o* define o
   recurso *feature*. Os recursos de tipo são denotados por
   sinalizadores de bit único.

int PyType_IS_GC(PyTypeObject *o)

   Retorna verdadeiro se o objeto tipo incluir suporte para o detector
   de ciclo; isso testa o sinalizador de tipo "Py_TPFLAGS_HAVE_GC".

int PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b)

   Retorna verdadeiro se *a* for um subtipo de *b*.

   Esta função só verifica pelos subtipos, o que significa que
   "__subclasscheck__()" não é chamado em *b*.  Chame
   "PyObject_IsSubclass()" para fazer a mesma verificação que
   "issubclass()" faria.

PyObject* PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)
    *Return value: New reference.*

   Manipulador genérico para o slot "tp_alloc" de um objeto tipo. Use
   o mecanismo de alocação de memória padrão do Python para alocar uma
   nova instância e inicializar todo o seu conteúdo para "NULL".

PyObject* PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
    *Return value: New reference.*

   Manipulador genérico para o slot "tp_new" de um objeto tipo. Cria
   uma nova instância usando o slot "tp_alloc" do tipo.

int PyType_Ready(PyTypeObject *type)

   Finaliza um objeto tipo. Isso deve ser chamado em todos os objetos
   tipo para finalizar sua inicialização. Esta função é responsável
   por adicionar slots herdados da classe base de um tipo. Retorna "0"
   em caso de sucesso, ou retorna "-1" e define uma exceção em caso de
   erro.

   Nota:

     If some of the base classes implements the GC protocol and the
     provided type does not include the "Py_TPFLAGS_HAVE_GC" in its
     flags, then the GC protocol will be automatically implemented
     from its parents. On the contrary, if the type being created does
     include "Py_TPFLAGS_HAVE_GC" in its flags then it **must**
     implement the GC protocol itself by at least implementing the
     "tp_traverse" handle.

void* PyType_GetSlot(PyTypeObject *type, int slot)

   Retorna o ponteiro de função armazenado no slot fornecido. Se o
   resultado for "NULL", isso indica que o slot é "NULL" ou que a
   função foi chamada com parâmetros inválidos. Os chamadores
   normalmente lançarão o ponteiro do resultado no tipo de função
   apropriado.

   Veja "PyType_Slot.slot" por possíveis valores do argumento *slot*.

   Uma exceção é levantada se *type* não é um tipo heap.

   Novo na versão 3.4.

PyObject* PyType_GetModule(PyTypeObject *type)

   Retorna o objeto de módulo associado ao tipo fornecido quando o
   tipo foi criado usando "PyType_FromModuleAndSpec()".

   Se nenhum módulo estiver associado com o tipo fornecido, define
   "TypeError" e retorna "NULL".

   This function is usually used to get the module in which a method
   is defined. Note that in such a method,
   "PyType_GetModule(Py_TYPE(self))" may not return the intended
   result. "Py_TYPE(self)" may be a *subclass* of the intended class,
   and subclasses are not necessarily defined in the same module as
   their superclass. See "PyCMethod" to get the class that defines the
   method.

   Novo na versão 3.9.

void* PyType_GetModuleState(PyTypeObject *type)

   Return the state of the module object associated with the given
   type. This is a shortcut for calling "PyModule_GetState()" on the
   result of "PyType_GetModule()".

   Se nenhum módulo estiver associado com o tipo fornecido, define
   "TypeError" e retorna "NULL".

   If the *type* has an associated module but its state is "NULL",
   returns "NULL" without setting an exception.

   Novo na versão 3.9.


Creating Heap-Allocated Types
=============================

The following functions and structs are used to create heap types.

PyObject* PyType_FromModuleAndSpec(PyObject *module, PyType_Spec *spec, PyObject *bases)
    *Return value: New reference.*

   Creates and returns a heap type object from the *spec*
   ("Py_TPFLAGS_HEAPTYPE").

   If *bases* is a tuple, the created heap type contains all types
   contained in it as base types.

   If *bases* is "NULL", the *Py_tp_bases* slot is used instead. If
   that also is "NULL", the *Py_tp_base* slot is used instead. If that
   also is "NULL", the new type derives from "object".

   The *module* argument can be used to record the module in which the
   new class is defined. It must be a module object or "NULL". If not
   "NULL", the module is associated with the new type and can later be
   retrieved with "PyType_GetModule()". The associated module is not
   inherited by subclasses; it must be specified for each class
   individually.

   This function calls "PyType_Ready()" on the new type.

   Novo na versão 3.9.

PyObject* PyType_FromSpecWithBases(PyType_Spec *spec, PyObject *bases)
    *Return value: New reference.*

   Equivalent to "PyType_FromModuleAndSpec(NULL, spec, bases)".

   Novo na versão 3.3.

PyObject* PyType_FromSpec(PyType_Spec *spec)
    *Return value: New reference.*

   Equivalent to "PyType_FromSpecWithBases(spec, NULL)".

PyType_Spec

   Structure defining a type's behavior.

   const char* PyType_Spec.name

      Name of the type, used to set "PyTypeObject.tp_name".

   int PyType_Spec.basicsize

   int PyType_Spec.itemsize

      Size of the instance in bytes, used to set
      "PyTypeObject.tp_basicsize" and "PyTypeObject.tp_itemsize".

   int PyType_Spec.flags

      Type flags, used to set "PyTypeObject.tp_flags".

      If the "Py_TPFLAGS_HEAPTYPE" flag is not set,
      "PyType_FromSpecWithBases()" sets it automatically.

   PyType_Slot *PyType_Spec.slots

      Array of "PyType_Slot" structures. Terminated by the special
      slot value "{0, NULL}".

PyType_Slot

   Structure defining optional functionality of a type, containing a
   slot ID and a value pointer.

   int PyType_Slot.slot

         A slot ID.

         Slot IDs are named like the field names of the structures
         "PyTypeObject", "PyNumberMethods", "PySequenceMethods",
         "PyMappingMethods" and "PyAsyncMethods" with an added "Py_"
         prefix. For example, use:

         * "Py_tp_dealloc" to set "PyTypeObject.tp_dealloc"

         * "Py_nb_add" to set "PyNumberMethods.nb_add"

         * "Py_sq_length" to set "PySequenceMethods.sq_length"

         The following fields cannot be set at all using "PyType_Spec"
         and "PyType_Slot":

         * "tp_dict"

         * "tp_mro"

         * "tp_cache"

         * "tp_subclasses"

         * "tp_weaklist"

         * "tp_vectorcall"

         * "tp_weaklistoffset" (see PyMemberDef)

         * "tp_dictoffset" (see PyMemberDef)

         * "tp_vectorcall_offset" (see PyMemberDef)

         The following fields cannot be set using "PyType_Spec" and
         "PyType_Slot" under the limited API:

         * "bf_getbuffer"

         * "bf_releasebuffer"

         Setting "Py_tp_bases" or "Py_tp_base" may be problematic on
         some platforms. To avoid issues, use the *bases* argument of
         "PyType_FromSpecWithBases()" instead.

      Alterado na versão 3.9: Slots in "PyBufferProcs" may be set in
      the unlimited API.

   void *PyType_Slot.pfunc

      The desired value of the slot. In most cases, this is a pointer
      to a function.

      May not be "NULL".
