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

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

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

PyTypeObject PyType_Type
    * Part of the Stable ABI.*

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

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

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.

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

   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)

   Return true if the type object includes support for the cycle
   detector; this tests the type flag "Py_TPFLAGS_HAVE_GC".

int PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b)
    * Part of the Stable ABI.*

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

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

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

   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.

PyObject *PyType_GetName(PyTypeObject *type)
    *Return value: New reference.** Part of the Stable ABI since
   version 3.11.*

   Retorna el nombre del tipo. Equivalente a obtener el atributo
   "__name__" del tipo.

   Nuevo en la versión 3.11.

PyObject *PyType_GetQualName(PyTypeObject *type)
    *Return value: New reference.** Part of the Stable ABI since
   version 3.11.*

   Retorna el nombre adecuado del tipo de objeto. Equivalente a
   obtener el atributo "__qualname__" del objeto tipo.

   Nuevo en la versión 3.11.

void *PyType_GetSlot(PyTypeObject *type, int slot)
    * Part of the Stable ABI since version 3.4.*

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

   Nuevo en la versión 3.4.

   Distinto en la versión 3.10: "PyType_GetSlot()" ahora puede aceptar
   todos los tipos. Anteriormente, estaba limitado a heap types.

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

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

   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. See "PyType_GetModuleByDef()" for cases when "PyCMethod"
   cannot be used.

   Nuevo en la versión 3.9.

void *PyType_GetModuleState(PyTypeObject *type)
    * Part of the Stable ABI since version 3.10.*

   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.

PyObject *PyType_GetModuleByDef(PyTypeObject *type, struct PyModuleDef *def)

   Encuentra la primer superclase cuyo módulo fue creado a partir del
   "PyModuleDef" *def* dado, y retorna ese módulo.

   Si no se encuentra ningún módulo, lanza "TypeError" y retorna
   "NULL".

   Esta función está pensada para ser utilizada junto con
   "PyModule_GetState()" para obtener el estado del módulo de los
   métodos de ranura (como "tp_init" o "nb_add") y en otros lugares
   donde la clase que define a un método no se puede pasar utilizando
   la convención de llamada "PyCMethod".

   Nuevo en la versión 3.11.


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

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

   El argumento *bases* se puede utilizar para especificar clases
   base; puede ser solo una clase o una tupla de clases. Si *bases* es
   "NULL", en su lugar se utiliza la ranura *Py_tp_bases*. Si esa
   también es "NULL", se usa la ranura *Py_tp_base* en su lugar. Si
   también es "NULL", el nuevo tipo se deriva de "object".

   El argumento *module* se puede utilizar para registrar el módulo en
   el que se define la nueva clase. Debe ser un objeto de módulo o
   "NULL". Si no es "NULL", el módulo se asocia con el nuevo tipo y
   luego se puede recuperar con "PyType_GetModule()". El módulo
   asociado no es heredado por subclases; debe especificarse para cada
   clase individualmente.

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

   Nuevo en la versión 3.9.

   Distinto en la versión 3.10: La función ahora acepta una sola clase
   como argumento *bases* y "NULL" como ranura "tp_doc".

PyObject *PyType_FromSpecWithBases(PyType_Spec *spec, PyObject *bases)
    *Return value: New reference.** Part of the Stable ABI since
   version 3.3.*

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

   Nuevo en la versión 3.3.

PyObject *PyType_FromSpec(PyType_Spec *spec)
    *Return value: New reference.** Part of the Stable ABI.*

   Equivalente a "PyType_FromSpecWithBases(spec, NULL)".

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

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

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

   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)

         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.

      Distinto en la versión 3.9: Las ranuras en "PyBufferProcs" se
      pueden configurar en la API ilimitada.

      Distinto en la versión 3.11: "bf_getbuffer" and
      "bf_releasebuffer" are now available under the limited 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.

      Las ranuras que no sean "Py_tp_doc" pueden no ser "NULL".
