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

type PyTypeObject
    * Part of the Limited API (as an opaque struct).*

   A estrutura C dos objetos usados para descrever tipos embutidos.

PyTypeObject PyType_Type
    * Part of the Stable ABI.*

   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()
    * Part of the Stable ABI.*

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

unsigned long PyType_GetFlags(PyTypeObject *type)
    * Part of the Stable ABI.*

   Return the "tp_flags" member of *type*. This function is primarily
   meant for use with "Py_LIMITED_API"; the individual flag bits are
   guaranteed to be stable across Python releases, but access to
   "tp_flags" itself is not part of the limited API.

   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)
    * Part of the Stable ABI.*

   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)
    * Part of the Stable ABI.*

   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)
    *Retorna valor: Nova referência.** Part of the Stable ABI.*

   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)
    *Retorna valor: Nova referência.** Part of the Stable ABI.*

   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)
    * Part of the Stable ABI.*

   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)
    * Part of the Stable ABI since version 3.4.*

   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*.

   Novo na versão 3.4.

   Alterado na versão 3.10: "PyType_GetSlot()" can now accept all
   types. Previously, it was limited to heap types.

PyObject *PyType_GetModule(PyTypeObject *type)
    * Part of the Stable ABI since version 3.10.*

   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)
    * Part of the Stable ABI since version 3.10.*

   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)
    *Retorna valor: Nova referência.** Part of the Stable ABI since
   version 3.10.*

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

   The *bases* argument can be used to specify base classes; it can
   either be only one class or a tuple of classes. 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.

   Alterado na versão 3.10: The function now accepts a single class as
   the *bases* argument and "NULL" as the "tp_doc" slot.

PyObject *PyType_FromSpecWithBases(PyType_Spec *spec, PyObject *bases)
    *Retorna valor: Nova referência.** Part of the Stable ABI since
   version 3.3.*

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

   Novo na versão 3.3.

PyObject *PyType_FromSpec(PyType_Spec *spec)
    *Retorna valor: Nova referência.** Part of the Stable ABI.*

   Equivalent to "PyType_FromSpecWithBases(spec, NULL)".

type PyType_Spec
    * Part of the Stable ABI (including all members).*

   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}".

type PyType_Slot
    * Part of the Stable ABI (including all members).*

   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.

      Slots other than "Py_tp_doc" may not be "NULL".
