型オブジェクト
**************

type PyTypeObject
    * 次に属します: Limited API (不透明な構造体として).*

   組み込み型を記述する際に用いられる、オブジェクトを表す C 構造体です
   。

PyTypeObject PyType_Type
    * 次に属します: Stable ABI.*

   型オブジェクト自身の型オブジェクトです。Python レイヤにおける
   "type" と同じオブジェクトです。

int PyType_Check(PyObject *o)

   Return non-zero if the object *o* is a type object, including
   instances of types derived from the standard type object.  Return 0
   in all other cases. This function always succeeds.

int PyType_CheckExact(PyObject *o)

   Return non-zero if the object *o* is a type object, but not a
   subtype of the standard type object.  Return 0 in all other cases.
   This function always succeeds.

unsigned int PyType_ClearCache()
    * 次に属します: Stable ABI.*

   内部の検索キャッシュをクリアします。現在のバージョンタグを返します
   。

unsigned long PyType_GetFlags(PyTypeObject *type)
    * 次に属します: 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.

   Added in version 3.2.

   バージョン 3.4 で変更: 返り値の型が "long" ではなく "unsigned long"
   になりました。

PyObject *PyType_GetDict(PyTypeObject *type)

   Return the type object's internal namespace, which is otherwise
   only exposed via a read-only proxy ("cls.__dict__").  This is a
   replacement for accessing "tp_dict" directly. The returned
   dictionary must be treated as read-only.

   This function is meant for specific embedding and language-binding
   cases, where direct access to the dict is necessary and indirect
   access (e.g. via the proxy or "PyObject_GetAttr()") isn't adequate.

   Extension modules should continue to use "tp_dict", directly or
   indirectly, when setting up their own types.

   Added in version 3.12.

void PyType_Modified(PyTypeObject *type)
    * 次に属します: Stable ABI.*

   内部の検索キャッシュを、その type とすべてのサブタイプに対して無効
   にします。この関数は type の属性や基底クラス列を変更したあとに手動
   で呼び出さなければなりません。

int PyType_AddWatcher(PyType_WatchCallback callback)

   Register *callback* as a type watcher. Return a non-negative
   integer ID which must be passed to future calls to
   "PyType_Watch()". In case of error (e.g. no more watcher IDs
   available), return "-1" and set an exception.

   Added in version 3.12.

int PyType_ClearWatcher(int watcher_id)

   Clear watcher identified by *watcher_id* (previously returned from
   "PyType_AddWatcher()"). Return "0" on success, "-1" on error (e.g.
   if *watcher_id* was never registered.)

   An extension should never call "PyType_ClearWatcher" with a
   *watcher_id* that was not returned to it by a previous call to
   "PyType_AddWatcher()".

   Added in version 3.12.

int PyType_Watch(int watcher_id, PyObject *type)

   Mark *type* as watched. The callback granted *watcher_id* by
   "PyType_AddWatcher()" will be called whenever "PyType_Modified()"
   reports a change to *type*. (The callback may be called only once
   for a series of consecutive modifications to *type*, if
   "_PyType_Lookup()" is not called on *type* between the
   modifications; this is an implementation detail and subject to
   change.)

   An extension should never call "PyType_Watch" with a *watcher_id*
   that was not returned to it by a previous call to
   "PyType_AddWatcher()".

   Added in version 3.12.

typedef int (*PyType_WatchCallback)(PyObject *type)

   Type of a type-watcher callback function.

   The callback must not modify *type* or cause "PyType_Modified()" to
   be called on *type* or any type in its MRO; violating this rule
   could cause infinite recursion.

   Added in version 3.12.

int PyType_HasFeature(PyTypeObject *o, int feature)

   Return non-zero if the type object *o* sets the feature *feature*.
   Type features are denoted by single bit flags.

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)
    * 次に属します: Stable ABI.*

   *a* が *b* のサブタイプの場合に真を返します。

   この関数は実際のサブクラスをチェックするだけです。つまり、
   "__subclasscheck__()" は *b* に対し呼ばれません。 "issubclass()" と
   同じチェックをするには "PyObject_IsSubclass()" を呼んでください。

PyObject *PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)
    *戻り値: 新しい参照。** 次に属します: Stable ABI.*

   型オブジェクトの "tp_alloc" に対するジェネリックハンドラです。
   Python のデフォルトのメモリアロケートメカニズムを使って新しいインス
   タンスをアロケートし、すべての内容を "NULL" で初期化します。

PyObject *PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
    *戻り値: 新しい参照。** 次に属します: Stable ABI.*

   型オブジェクトの "tp_new" に対するジェネリックハンドラです。型の
   "tp_alloc" スロットを使って新しいインスタンスを作成します。

int PyType_Ready(PyTypeObject *type)
    * 次に属します: Stable ABI.*

   型オブジェクトのファイナライズを行います。この関数は全てのオブジェ
   クトで初期化を完了するために呼び出されなくてはなりません。この関数
   は、基底クラス型から継承したスロットを型オブジェクトに追加する役割
   があります。成功した場合には "0" を返し、エラーの場合には "-1" を返
   して例外情報を設定します。

   注釈:

     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)
    *戻り値: 新しい参照。** 次に属します: Stable ABI (バージョン 3.11
   より).*

   Return the type's name. Equivalent to getting the type's "__name__"
   attribute.

   Added in version 3.11.

PyObject *PyType_GetQualName(PyTypeObject *type)
    *戻り値: 新しい参照。** 次に属します: Stable ABI (バージョン 3.11
   より).*

   Return the type's qualified name. Equivalent to getting the type's
   "__qualname__" attribute.

   Added in version 3.11.

void *PyType_GetSlot(PyTypeObject *type, int slot)
    * 次に属します: Stable ABI (バージョン 3.4 より).*

   与えられたスロットに格納されている関数ポインタを返します。返り値が
   "NULL" の場合は、スロットが "NULL" か、関数が不正な引数で呼ばれたこ
   とを示します。通常、呼び出し側は返り値のポインタを適切な関数型にキ
   ャストします。

   See "PyType_Slot.slot" for possible values of the *slot* argument.

   Added in version 3.4.

   バージョン 3.10 で変更: "PyType_GetSlot()" can now accept all
   types. Previously, it was limited to heap types.

PyObject *PyType_GetModule(PyTypeObject *type)
    * 次に属します: Stable ABI (バージョン 3.10 より).*

   Return the module object associated with the given type when the
   type was created using "PyType_FromModuleAndSpec()".

   If no module is associated with the given type, sets "TypeError"
   and returns "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.

   Added in version 3.9.

void *PyType_GetModuleState(PyTypeObject *type)
    * 次に属します: Stable ABI (バージョン 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()".

   If no module is associated with the given type, sets "TypeError"
   and returns "NULL".

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

   Added in version 3.9.

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

   Find the first superclass whose module was created from the given
   "PyModuleDef" *def*, and return that module.

   If no module is found, raises a "TypeError" and returns "NULL".

   This function is intended to be used together with
   "PyModule_GetState()" to get module state from slot methods (such
   as "tp_init" or "nb_add") and other places where a method's
   defining class cannot be passed using the "PyCMethod" calling
   convention.

   Added in version 3.11.

int PyUnstable_Type_AssignVersionTag(PyTypeObject *type)

   *これは Unstable APIです。マイナーリリースで予告なく変更されること
   があります。*

   Attempt to assign a version tag to the given type.

   Returns 1 if the type already had a valid version tag or a new one
   was assigned, or 0 if a new tag could not be assigned.

   Added in version 3.12.


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

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

PyObject *PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases)
    * 次に属します: Stable ABI (バージョン 3.12 より).*

   Create and return a heap type from the *spec* (see
   "Py_TPFLAGS_HEAPTYPE").

   The metaclass *metaclass* is used to construct the resulting type
   object. When *metaclass* is "NULL", the metaclass is derived from
   *bases* (or *Py_tp_base[s]* slots if *bases* is "NULL", see below).

   Metaclasses that override "tp_new" are not supported, except if
   "tp_new" is "NULL". (For backwards compatibility, other
   "PyType_From*" functions allow such metaclasses. They ignore
   "tp_new", which may result in incomplete initialization. This is
   deprecated and in Python 3.14+ such metaclasses will not be
   supported.)

   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.

   Note that this function does *not* fully match the behavior of
   calling "type()" or using the "class" statement. With user-provided
   base types or metaclasses, prefer calling "type" (or the metaclass)
   over "PyType_From*" functions. Specifically:

   * "__new__()" is not called on the new class (and it must be set to
     "type.__new__").

   * "__init__()" is not called on the new class.

   * "__init_subclass__()" is not called on any bases.

   * "__set_name__()" is not called on new descriptors.

   Added in version 3.12.

PyObject *PyType_FromModuleAndSpec(PyObject *module, PyType_Spec *spec, PyObject *bases)
    *戻り値: 新しい参照。** 次に属します: Stable ABI (バージョン 3.10
   より).*

   Equivalent to "PyType_FromMetaclass(NULL, module, spec, bases)".

   Added in version 3.9.

   バージョン 3.10 で変更: The function now accepts a single class as
   the *bases* argument and "NULL" as the "tp_doc" slot.

   バージョン 3.12 で変更: The function now finds and uses a metaclass
   corresponding to the provided base classes.  Previously, only
   "type" instances were returned.The "tp_new" of the metaclass is
   *ignored*. which may result in incomplete initialization. Creating
   classes whose metaclass overrides "tp_new" is deprecated and in
   Python 3.14+ it will be no longer allowed.

PyObject *PyType_FromSpecWithBases(PyType_Spec *spec, PyObject *bases)
    *戻り値: 新しい参照。** 次に属します: Stable ABI (バージョン 3.3
   より).*

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

   Added in version 3.3.

   バージョン 3.12 で変更: The function now finds and uses a metaclass
   corresponding to the provided base classes.  Previously, only
   "type" instances were returned.The "tp_new" of the metaclass is
   *ignored*. which may result in incomplete initialization. Creating
   classes whose metaclass overrides "tp_new" is deprecated and in
   Python 3.14+ it will be no longer allowed.

PyObject *PyType_FromSpec(PyType_Spec *spec)
    *戻り値: 新しい参照。** 次に属します: Stable ABI.*

   Equivalent to "PyType_FromMetaclass(NULL, NULL, spec, NULL)".

   バージョン 3.12 で変更: The function now finds and uses a metaclass
   corresponding to the base classes provided in *Py_tp_base[s]*
   slots. Previously, only "type" instances were returned.The "tp_new"
   of the metaclass is *ignored*. which may result in incomplete
   initialization. Creating classes whose metaclass overrides "tp_new"
   is deprecated and in Python 3.14+ it will be no longer allowed.

type PyType_Spec
    * 次に属します: Stable ABI (すべてのメンバーを含む).*

   Structure defining a type's behavior.

   const char *name

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

   int basicsize

      If positive, specifies the size of the instance in bytes. It is
      used to set "PyTypeObject.tp_basicsize".

      If zero, specifies that "tp_basicsize" should be inherited.

      If negative, the absolute value specifies how much space
      instances of the class need *in addition* to the superclass. Use
      "PyObject_GetTypeData()" to get a pointer to subclass-specific
      memory reserved this way.

      バージョン 3.12 で変更: Previously, this field could not be
      negative.

   int itemsize

      Size of one element of a variable-size type, in bytes. Used to
      set "PyTypeObject.tp_itemsize". See "tp_itemsize" documentation
      for caveats.

      If zero, "tp_itemsize" is inherited. Extending arbitrary
      variable-sized classes is dangerous, since some types use a
      fixed offset for variable-sized memory, which can then overlap
      fixed-sized memory used by a subclass. To help prevent mistakes,
      inheriting "itemsize" is only possible in the following
      situations:

      * The base is not variable-sized (its "tp_itemsize").

      * The requested "PyType_Spec.basicsize" is positive, suggesting
        that the memory layout of the base class is known.

      * The requested "PyType_Spec.basicsize" is zero, suggesting that
        the subclass does not access the instance's memory directly.

      * With the "Py_TPFLAGS_ITEMS_AT_END" flag.

   unsigned int 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 *slots

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

      Each slot ID should be specified at most once.

type PyType_Slot
    * 次に属します: Stable ABI (すべてのメンバーを含む).*

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

   int 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 “offset” fields cannot be set using
         "PyType_Slot":

            * "tp_weaklistoffset" (use "Py_TPFLAGS_MANAGED_WEAKREF"
              instead if possible)

            * "tp_dictoffset" (use "Py_TPFLAGS_MANAGED_DICT" instead
              if possible)

            * "tp_vectorcall_offset" (use ""__vectorcalloffset__"" in
              PyMemberDef)

            If it is not possible to switch to a "MANAGED" flag (for
            example, for vectorcall or to support Python older than
            3.12), specify the offset in "Py_tp_members". See
            PyMemberDef documentation for details.

         The following fields cannot be set at all when creating a
         heap type:

         * "tp_vectorcall" (use "tp_new" and/or "tp_init")

         * Internal fields: "tp_dict", "tp_mro", "tp_cache",
           "tp_subclasses", and "tp_weaklist".

         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.

      バージョン 3.9 で変更: Slots in "PyBufferProcs" may be set in
      the unlimited API.

      バージョン 3.11 で変更: "bf_getbuffer" and "bf_releasebuffer"
      are now available under the limited API.

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