Objetos Tipos
*************

PyTypeObject

   La estructura C de los objetos utilizados para describir los tipos
   incorporados.

PyTypeObject PyType_Type

   Este es el objeto tipo para objetos tipo; es el mismo objeto que
   "type" en la capa Python.

int PyType_Check(PyObject *o)

   Retorna un valor distinto de cero si el objeto *o* es un objeto
   tipo, incluidas las instancias de tipos derivados del objeto de
   tipo estándar. Retorna 0 en todos los demás casos. Esta función
   siempre finaliza con éxito.

int PyType_CheckExact(PyObject *o)

   Retorna un valor distinto de cero si el objeto *o* es un objeto
   tipo, pero no un subtipo del objeto tipo estándar. Retorna 0 en
   todos los demás casos. Esta función siempre finaliza con éxito.

unsigned int PyType_ClearCache()

   Borra la caché de búsqueda interna. Retorna la etiqueta (*tag*) de
   la versión actual.

unsigned long PyType_GetFlags(PyTypeObject* type)

   Retorna el miembro "tp_flags" de *type*. Esta función está
   destinada principalmente para su uso con *Py_LIMITED_API*; se
   garantiza que los bits de bandera (*flag*) individuales serán
   estables en las versiones de Python, pero el acceso a "tp_flags" en
   sí mismo no forma parte de la API limitada.

   Nuevo en la versión 3.2.

   Distinto en la versión 3.4: El tipo de retorno es ahora "unsigned
   long" en vez de "long".

void PyType_Modified(PyTypeObject *type)

   Invalida la memoria caché de búsqueda interna para el tipo y todos
   sus subtipos. Esta función debe llamarse después de cualquier
   modificación manual de los atributos o clases base del tipo.

int PyType_HasFeature(PyTypeObject *o, int feature)

   Retorna un valor distinto de cero si el tipo objeto *o* establece
   la característica *feature*. Las características de tipo se indican
   mediante flags de un solo bit.

int PyType_IS_GC(PyTypeObject *o)

   Retorna verdadero si el objeto tipo incluye soporte para el
   detector de ciclo; Esto prueba el indicador de tipo
   "Py_TPFLAGS_HAVE_GC".

int PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b)

   Retorna verdadero si *a* es un subtipo de *b*.

   Esta función solo busca subtipos reales, lo que significa que
   "__subclasscheck__()" no se llama en *b*. Llama
   "PyObject_IsSubclass()" para hacer el mismo chequeo que
   "issubclass()" haría.

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

   Controlador genérico para la ranura "tp_alloc" de un objeto tipo.
   Usa el mecanismo de asignación de memoria predeterminado de Python
   para asignar una nueva instancia e inicializar todo su contenido a
   "NULL".

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

   Controlador genérico para la ranura "tp_new" de un objeto tipo.
   Crea una nueva instancia utilizando la ranura del tipo "tp_alloc".

int PyType_Ready(PyTypeObject *type)

   Finalizar un objeto tipo. Se debe llamar a todos los objetos tipo
   para finalizar su inicialización. Esta función es responsable de
   agregar ranuras heredadas de la clase base de un tipo. Retorna "0"
   en caso de éxito o retorna "-1" y establece una excepción en caso
   de error.

   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 el puntero de función almacenado en la ranura dada. Si el
   resultado es "NULL", esto indica que la ranura es "NULL" o que la
   función se llamó con parámetros no válidos. Las personas que llaman
   suelen convertir el puntero de resultado en el tipo de función
   apropiado.

   Consulte "PyType_Slot.slot" para conocer los posibles valores del
   argumento *slot*.

   Se lanza una excepción si *type* no es un tipo montículo (*heap*).

   Nuevo en la versión 3.4.

PyObject* PyType_GetModule(PyTypeObject *type)

   Retorna el objeto módulo asociado con el tipo dado cuando se creó
   el tipo usando "PyType_FromModuleAndSpec()".

   Si no hay ningún módulo asociado con el tipo dado, establece
   "TypeError" y retorna "NULL".

   Esta función se suele utilizar para obtener el módulo en el que se
   define un método. Tenga en cuenta que en un método de este tipo, es
   posible que "PyType_GetModule(Py_TYPE(self))" no retorne el
   resultado deseado. "Py_TYPE(self)" puede ser una *subclass* de la
   clase deseada, y las subclases no están necesariamente definidas en
   el mismo módulo que su superclase. Consulte "PyCMethod" para
   obtener la clase que define el método.

   Nuevo en la versión 3.9.

void* PyType_GetModuleState(PyTypeObject *type)

   Retorna el estado del objeto de módulo asociado con el tipo dado.
   Este es un atajo para llamar "PyModule_GetState()" en el resultado
   de "PyType_GetModule()".

   Si no hay ningún módulo asociado con el tipo dado, establece
   "TypeError" y retorna "NULL".

   Si el tipo *type* tiene un módulo asociado pero su estado es
   "NULL", retorna "NULL" sin establecer una excepción.

   Nuevo en la versión 3.9.


Crear tipos asignados en montículo (*heap*)
===========================================

Las siguientes funciones y estructuras se utilizan para crear heap
types.

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

   Crea y retorna un objeto montículo (*heap*) a partir de *spec*
   ("Py_TPFLAGS_HEAPTYPE").

   Si *bases* es una tupla, el tipo montículo (*heap*) creado contiene
   todos los tipos contenidos en él como tipos básicos.

   Si *bases* es "NULL", en su lugar se usa la ranura *Py_tp_base*. Si
   eso también es "NULL", en su lugar, se utiliza la ranura
   *Py_tp_base*. Si eso también es "NULL", el nuevo tipo se deriva de
   "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.

   Esta función llama "PyType_Ready()" en el tipo nuevo.

   Nuevo en la versión 3.9.

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

   Equivalente a "PyType_FromModuleAndSpec(NULL, spec, bases)".

   Nuevo en la versión 3.3.

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

   Equivalente a "PyType_FromSpecWithBases(spec, NULL)".

PyType_Spec

   Estructura que define el comportamiento de un tipo.

   const char* PyType_Spec.name

      Nombre del tipo, utilizado para establecer
      "PyTypeObject.tp_name".

   int PyType_Spec.basicsize

   int PyType_Spec.itemsize

      Tamaño de la instancia en bytes, utilizado para establecer
      "PyTypeObject.tp_basicsize" y "PyTypeObject.tp_itemsize".

   int PyType_Spec.flags

      Banderas (*flags*) del tipo, que se usan para establecer
      "PyTypeObject.tp_flags".

      Si el indicador "Py_TPFLAGS_HEAPTYPE" no está establecido,
      "PyType_FromSpecWithBases()" lo establece automáticamente.

   PyType_Slot *PyType_Spec.slots

      Arreglo de estructuras "PyType_Slot". Terminado por el valor de
      ranura especial "{0, NULL}".

PyType_Slot

   Estructura que define la funcionalidad opcional de un tipo, que
   contiene una ranura ID y un puntero de valor.

   int PyType_Slot.slot

         Una ranura ID.

         Las ranuras IDs se nombran como los nombres de campo de las
         estructuras "PyTypeObject", "PyNumberMethods",
         "PySequenceMethods", "PyMappingMethods" y "PyAsyncMethods"
         con un prefijo "Py_" agregado. Por ejemplo, use:

         * "Py_tp_dealloc" para establecer "PyTypeObject.tp_dealloc"

         * "Py_nb_add" para establecer "PyNumberMethods.nb_add"

         * "Py_sq_length" para establecer
           "PySequenceMethods.sq_length"

         Los siguientes campos no se pueden configurar en absoluto
         usando "PyType_Spec" y "PyType_Slot":

         * "tp_dict"

         * "tp_mro"

         * "tp_cache"

         * "tp_subclasses"

         * "tp_weaklist"

         * "tp_vectorcall"

         * "tp_weaklistoffset" (vea PyMemberDef)

         * "tp_dictoffset" (vea PyMemberDef)

         * "tp_vectorcall_offset" (vea PyMemberDef)

         Los siguientes campos no se pueden establecer usando
         "PyType_Spec" y "PyType_Slot" cuando se utiliza la API
         limitada:

         * "bf_getbuffer"

         * "bf_releasebuffer"

         Estableciendo "Py_tp_bases" o "Py_tp_base" puede ser
         problemático en algunas plataformas. Para evitar problemas,
         use el argumento *bases* de "PyType_FromSpecWithBases()" en
         su lugar.

      Distinto en la versión 3.9: Slots in "PyBufferProcs" may be set
      in the unlimited API.

   void *PyType_Slot.pfunc

      El valor deseado de la ranura. En la mayoría de los casos, este
      es un puntero a una función.

      Puede no ser "NULL".
