from typing import Callable, TypeVar, Union

from ._pyapi import API_FUNCS, Func

from .base_pointers import BaseObjectPointer

from .bindings import (

CharLike,

PointerLike,

StringLike,

binding_base,

make_char,

make_string,

)

from .std_structs import *

from .structure import StructPointer

def api_binding_base(data: Func, *args):

func = data[0]

if not func:

name: str = data[2]

minver = data[1]

raise NotImplementedError(

f"{name} is only supported on versions {data[1]}+"

if minver

else f"{name} is not supported on this version",

)

return binding_base(func, *args)

class DumbassError(Exception):

"""lmao"""

class _CallBase:

def __init__(self):

raise DumbassError("this is a namespace")

T = TypeVar("T")

PyObjectLike = Union[T, BaseObjectPointer[T]]

def _deref_maybe(ob: PyObjectLike[T]) -> T:

if isinstance(ob, BaseObjectPointer):

return ~ob

return ob

# autogenerated

__all__ = (

"PyAIter",

"PyArg",

"PyBool",

"PyBuffer",

"PyByteArray",

"PyBytes",

"PyCallIter",

"PyCallable",

"PyCapsule",

"PyCodec",

"PyComplex",

"PyDescr",

"PyDictProxy",

"PyDict",

"PyErr",

"PyEval",

"PyException",

"PyFile",

"PyFloat",

"PyFrame",

"PyFrozenSet",

"PyGC",

"PyGILState",

"PyImport",

"PyIndex",

"PyInterpreterState",

"PyIter",

"PyList",

"PyLong",

"PyMapping",

"PyMem",

"PyMemoryView",

"PyModuleDef",

"PyModule",

"PyNumber",

"PyOS",

"PyObject",

"PySeqIter",

"PySequence",

"PySet",

"PySlice",

"PyState",

"PyStructSequence",

"PySys",

"PyThreadState",

"PyThread",

"PyTuple",

"PyType",

"PyUnicodeDecodeError",

"PyUnicodeEncodeError",

"PyUnicodeTranslateError",

"PyUnicode",

"PyWeakref",

"Py",

"PyContext",

"_PyWarnings",

"_PyFrame",

"_Py",

"PyCompile",

"_PyTraceback",

"_PyImport",

"_PyErr",

"_PyInterpreterState",

"_PyBytesWriter",

"_PyEval",

"_PyDictView",

"_PyRun",

"_PySys",

"_PyTuple",

"_PyNumber",

"_PyAST",

"_PyStructSequence",

"_PyObject",

"_PyType",

"_PyDict",

)

class PyAIter(_CallBase):

"""Namespace containing API functions prefixed with `PyAIter_`"""

# PyAIter_Check

@staticmethod

def check(o: PyObjectLike) -> int:

return api_binding_base(API_FUNCS["PyAIter_Check"], _deref_maybe(o))

class PyArg(_CallBase):

"""Namespace containing API functions prefixed with `PyArg_`"""

# PyArg_VaParse

@staticmethod

def va_parse(args: PyObjectLike, format: StringLike, vargs: PointerLike) -> int:

return api_binding_base(

API_FUNCS["PyArg_VaParse"], _deref_maybe(args), make_string(format), vargs

)

# PyArg_VaParseTupleAndKeywords

@staticmethod

def va_parse_tuple_and_keywords(

args: PyObjectLike,

kw: PyObjectLike,

format: StringLike,

keywords: PointerLike,

vargs: PointerLike,

) -> int:

return api_binding_base(

API_FUNCS["PyArg_VaParseTupleAndKeywords"],

_deref_maybe(args),

_deref_maybe(kw),

make_string(format),

keywords,

vargs,

)

class PyBool(_CallBase):

"""Namespace containing API functions prefixed with `PyBool_`"""

# PyBool_FromLong

@staticmethod

def from_long(v: int) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyBool_FromLong"], v)

class PyBuffer(_CallBase):

"""Namespace containing API functions prefixed with `PyBuffer_`"""

# PyBuffer_FillContiguousStrides

@staticmethod

def fill_contiguous_strides(

ndims: int,

shape: PointerLike,

strides: PointerLike,

itemsize: int,

order: CharLike,

) -> None:

return api_binding_base(

API_FUNCS["PyBuffer_FillContiguousStrides"],

ndims,

shape,

strides,

itemsize,

make_char(order),

)

# PyBuffer_FillInfo

@staticmethod

def fill_info(

view: StructPointer[Buffer],

exporter: PyObjectLike,

buf: PointerLike,

len: int,

readonly: int,

flags: int,

) -> int:

return api_binding_base(

API_FUNCS["PyBuffer_FillInfo"],

view,

_deref_maybe(exporter),

buf,

len,

readonly,

flags,

)

# PyBuffer_FromContiguous

@staticmethod

def from_contiguous(

view: StructPointer[Buffer], buf: PointerLike, len: int, fort: CharLike

) -> int:

return api_binding_base(

API_FUNCS["PyBuffer_FromContiguous"], view, buf, len, make_char(fort)

)

# PyBuffer_GetPointer

@staticmethod

def get_pointer(view: StructPointer[Buffer], indices: PointerLike) -> PointerLike:

return api_binding_base(API_FUNCS["PyBuffer_GetPointer"], view, indices)

# PyBuffer_IsContiguous

@staticmethod

def is_contiguous(view: StructPointer[Buffer], order: CharLike) -> int:

return api_binding_base(

API_FUNCS["PyBuffer_IsContiguous"], view, make_char(order)

)

# PyBuffer_Release

@staticmethod

def release(view: StructPointer[Buffer]) -> None:

return api_binding_base(API_FUNCS["PyBuffer_Release"], view)

# PyBuffer_SizeFromFormat

@staticmethod

def size_from_format(format: StringLike) -> int:

return api_binding_base(

API_FUNCS["PyBuffer_SizeFromFormat"], make_string(format)

)

# PyBuffer_ToContiguous

@staticmethod

def to_contiguous(

buf: PointerLike, src: StructPointer[Buffer], len: int, order: CharLike

) -> int:

return api_binding_base(

API_FUNCS["PyBuffer_ToContiguous"], buf, src, len, make_char(order)

)

class PyByteArray(_CallBase):

"""Namespace containing API functions prefixed with `PyByteArray_`"""

# PyByteArray_AsString

@staticmethod

def as_string(bytearray: PyObjectLike) -> StringLike:

return api_binding_base(

API_FUNCS["PyByteArray_AsString"], _deref_maybe(bytearray)

)

# PyByteArray_Concat

@staticmethod

def concat(a: PyObjectLike, b: PyObjectLike) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyByteArray_Concat"], _deref_maybe(a), _deref_maybe(b)

)

# PyByteArray_FromObject

@staticmethod

def from_object(o: PyObjectLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyByteArray_FromObject"], _deref_maybe(o))

# PyByteArray_FromStringAndSize

@staticmethod

def from_string_and_size(string: StringLike, len: int) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyByteArray_FromStringAndSize"], make_string(string), len

)

# PyByteArray_Resize

@staticmethod

def resize(bytearray: PyObjectLike, len: int) -> int:

return api_binding_base(

API_FUNCS["PyByteArray_Resize"], _deref_maybe(bytearray), len

)

# PyByteArray_Size

@staticmethod

def size(bytearray: PyObjectLike) -> int:

return api_binding_base(API_FUNCS["PyByteArray_Size"], _deref_maybe(bytearray))

class PyBytes(_CallBase):

"""Namespace containing API functions prefixed with `PyBytes_`"""

# PyBytes_AsString

@staticmethod

def as_string(o: PyObjectLike) -> StringLike:

return api_binding_base(API_FUNCS["PyBytes_AsString"], _deref_maybe(o))

# PyBytes_AsStringAndSize

@staticmethod

def as_string_and_size(

obj: PyObjectLike, buffer: PointerLike, length: PointerLike

) -> int:

return api_binding_base(

API_FUNCS["PyBytes_AsStringAndSize"], _deref_maybe(obj), buffer, length

)

# PyBytes_Concat

@staticmethod

def concat(bytes: PointerLike, newpart: PyObjectLike) -> None:

return api_binding_base(

API_FUNCS["PyBytes_Concat"], bytes, _deref_maybe(newpart)

)

# PyBytes_ConcatAndDel

@staticmethod

def concat_and_del(bytes: PointerLike, newpart: PyObjectLike) -> None:

return api_binding_base(

API_FUNCS["PyBytes_ConcatAndDel"], bytes, _deref_maybe(newpart)

)

# PyBytes_FromFormatV

@staticmethod

def from_format_v(format: StringLike, vargs: PointerLike) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyBytes_FromFormatV"], make_string(format), vargs

)

# PyBytes_FromObject

@staticmethod

def from_object(o: PyObjectLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyBytes_FromObject"], _deref_maybe(o))

# PyBytes_FromString

@staticmethod

def from_string(v: StringLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyBytes_FromString"], make_string(v))

# PyBytes_FromStringAndSize

@staticmethod

def from_string_and_size(v: StringLike, len: int) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyBytes_FromStringAndSize"], make_string(v), len

)

# PyBytes_Size

@staticmethod

def size(o: PyObjectLike) -> int:

return api_binding_base(API_FUNCS["PyBytes_Size"], _deref_maybe(o))

class PyCallIter(_CallBase):

"""Namespace containing API functions prefixed with `PyCallIter_`"""

# PyCallIter_New

@staticmethod

def new(callable: PyObjectLike, sentinel: PyObjectLike) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyCallIter_New"], _deref_maybe(callable), _deref_maybe(sentinel)

)

class PyCallable(_CallBase):

"""Namespace containing API functions prefixed with `PyCallable_`"""

# PyCallable_Check

@staticmethod

def check(o: PyObjectLike) -> int:

return api_binding_base(API_FUNCS["PyCallable_Check"], _deref_maybe(o))

class PyCapsule(_CallBase):

"""Namespace containing API functions prefixed with `PyCapsule_`"""

# PyCapsule_GetContext

@staticmethod

def get_context(capsule: PyObjectLike) -> PointerLike:

return api_binding_base(

API_FUNCS["PyCapsule_GetContext"], _deref_maybe(capsule)

)

# PyCapsule_GetDestructor

@staticmethod

def get_destructor(capsule: PyObjectLike) -> PointerLike:

return api_binding_base(

API_FUNCS["PyCapsule_GetDestructor"], _deref_maybe(capsule)

)

# PyCapsule_GetName

@staticmethod

def get_name(capsule: PyObjectLike) -> StringLike:

return api_binding_base(API_FUNCS["PyCapsule_GetName"], _deref_maybe(capsule))

# PyCapsule_GetPointer

@staticmethod

def get_pointer(capsule: PyObjectLike, name: StringLike) -> PointerLike:

return api_binding_base(

API_FUNCS["PyCapsule_GetPointer"], _deref_maybe(capsule), make_string(name)

)

# PyCapsule_Import

@staticmethod

def import_(name: StringLike, no_block: int) -> PointerLike:

return api_binding_base(

API_FUNCS["PyCapsule_Import"], make_string(name), no_block

)

# PyCapsule_IsValid

@staticmethod

def is_valid(capsule: PyObjectLike, name: StringLike) -> int:

return api_binding_base(

API_FUNCS["PyCapsule_IsValid"], _deref_maybe(capsule), make_string(name)

)

# PyCapsule_New

@staticmethod

def new(

pointer: PointerLike, name: StringLike, destructor: PointerLike

) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyCapsule_New"], pointer, make_string(name), destructor

)

# PyCapsule_SetContext

@staticmethod

def set_context(capsule: PyObjectLike, context: PointerLike) -> int:

return api_binding_base(

API_FUNCS["PyCapsule_SetContext"], _deref_maybe(capsule), context

)

# PyCapsule_SetDestructor

@staticmethod

def set_destructor(capsule: PyObjectLike, destructor: PointerLike) -> int:

return api_binding_base(

API_FUNCS["PyCapsule_SetDestructor"], _deref_maybe(capsule), destructor

)

# PyCapsule_SetName

@staticmethod

def set_name(capsule: PyObjectLike, name: StringLike) -> int:

return api_binding_base(

API_FUNCS["PyCapsule_SetName"], _deref_maybe(capsule), make_string(name)

)

# PyCapsule_SetPointer

@staticmethod

def set_pointer(capsule: PyObjectLike, pointer: PointerLike) -> int:

return api_binding_base(

API_FUNCS["PyCapsule_SetPointer"], _deref_maybe(capsule), pointer

)

class PyCodec(_CallBase):

"""Namespace containing API functions prefixed with `PyCodec_`"""

# PyCodec_BackslashReplaceErrors

@staticmethod

def backslash_replace_errors(exc: PyObjectLike) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyCodec_BackslashReplaceErrors"], _deref_maybe(exc)

)

# PyCodec_Decode

@staticmethod

def decode(

object: PyObjectLike, encoding: StringLike, errors: StringLike

) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyCodec_Decode"],

_deref_maybe(object),

make_string(encoding),

make_string(errors),

)

# PyCodec_Decoder

@staticmethod

def decoder(encoding: StringLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyCodec_Decoder"], make_string(encoding))

# PyCodec_Encode

@staticmethod

def encode(

object: PyObjectLike, encoding: StringLike, errors: StringLike

) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyCodec_Encode"],

_deref_maybe(object),

make_string(encoding),

make_string(errors),

)

# PyCodec_Encoder

@staticmethod

def encoder(encoding: StringLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyCodec_Encoder"], make_string(encoding))

# PyCodec_IgnoreErrors

@staticmethod

def ignore_errors(exc: PyObjectLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyCodec_IgnoreErrors"], _deref_maybe(exc))

# PyCodec_IncrementalDecoder

@staticmethod

def incremental_decoder(encoding: StringLike, errors: StringLike) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyCodec_IncrementalDecoder"],

make_string(encoding),

make_string(errors),

)

# PyCodec_IncrementalEncoder

@staticmethod

def incremental_encoder(encoding: StringLike, errors: StringLike) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyCodec_IncrementalEncoder"],

make_string(encoding),

make_string(errors),

)

# PyCodec_KnownEncoding

@staticmethod

def known_encoding(encoding: StringLike) -> int:

return api_binding_base(

API_FUNCS["PyCodec_KnownEncoding"], make_string(encoding)

)

# PyCodec_LookupError

@staticmethod

def lookup_error(name: StringLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyCodec_LookupError"], make_string(name))

# PyCodec_NameReplaceErrors

@staticmethod

def name_replace_errors(exc: PyObjectLike) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyCodec_NameReplaceErrors"], _deref_maybe(exc)

)

# PyCodec_Register

@staticmethod

def register(search_function: PyObjectLike) -> int:

return api_binding_base(

API_FUNCS["PyCodec_Register"], _deref_maybe(search_function)

)

# PyCodec_RegisterError

@staticmethod

def register_error(name: StringLike, error: PyObjectLike) -> int:

return api_binding_base(

API_FUNCS["PyCodec_RegisterError"], make_string(name), _deref_maybe(error)

)

# PyCodec_ReplaceErrors

@staticmethod

def replace_errors(exc: PyObjectLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyCodec_ReplaceErrors"], _deref_maybe(exc))

# PyCodec_StreamReader

@staticmethod

def stream_reader(

encoding: StringLike, stream: PyObjectLike, errors: StringLike

) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyCodec_StreamReader"],

make_string(encoding),

_deref_maybe(stream),

make_string(errors),

)

# PyCodec_StreamWriter

@staticmethod

def stream_writer(

encoding: StringLike, stream: PyObjectLike, errors: StringLike

) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyCodec_StreamWriter"],

make_string(encoding),

_deref_maybe(stream),

make_string(errors),

)

# PyCodec_StrictErrors

@staticmethod

def strict_errors(exc: PyObjectLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyCodec_StrictErrors"], _deref_maybe(exc))

# PyCodec_Unregister

@staticmethod

def unregister(search_function: PyObjectLike) -> int:

return api_binding_base(

API_FUNCS["PyCodec_Unregister"], _deref_maybe(search_function)

)

# PyCodec_XMLCharRefReplaceErrors

@staticmethod

def x_m_l_char_ref_replace_errors(exc: PyObjectLike) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyCodec_XMLCharRefReplaceErrors"], _deref_maybe(exc)

)

class PyComplex(_CallBase):

"""Namespace containing API functions prefixed with `PyComplex_`"""

# PyComplex_FromDoubles

@staticmethod

def from_doubles(real: int, imag: int) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyComplex_FromDoubles"], real, imag)

# PyComplex_ImagAsDouble

@staticmethod

def imag_as_double(op: PyObjectLike) -> int:

return api_binding_base(API_FUNCS["PyComplex_ImagAsDouble"], _deref_maybe(op))

# PyComplex_RealAsDouble

@staticmethod

def real_as_double(op: PyObjectLike) -> int:

return api_binding_base(API_FUNCS["PyComplex_RealAsDouble"], _deref_maybe(op))

class PyDescr(_CallBase):

"""Namespace containing API functions prefixed with `PyDescr_`"""

# PyDescr_NewClassMethod

@staticmethod

def new_class_method(

type: StructPointer[TypeObject], method: StructPointer[MethodDef]

) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyDescr_NewClassMethod"], type, method)

# PyDescr_NewGetSet

@staticmethod

def new_get_set(

type: StructPointer[TypeObject], getset: StructPointer[GetSetDef]

) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyDescr_NewGetSet"], type, getset)

# PyDescr_NewMember

@staticmethod

def new_member(type: StructPointer[TypeObject]) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyDescr_NewMember"], type)

# PyDescr_NewMethod

@staticmethod

def new_method(

type: StructPointer[TypeObject], meth: StructPointer[MethodDef]

) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyDescr_NewMethod"], type, meth)

class PyDictProxy(_CallBase):

"""Namespace containing API functions prefixed with `PyDictProxy_`"""

# PyDictProxy_New

@staticmethod

def new(mapping: PyObjectLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyDictProxy_New"], _deref_maybe(mapping))

class PyDict(_CallBase):

"""Namespace containing API functions prefixed with `PyDict_`"""

# PyDict_Clear

@staticmethod

def clear(p: PyObjectLike) -> None:

return api_binding_base(API_FUNCS["PyDict_Clear"], _deref_maybe(p))

# PyDict_Contains

@staticmethod

def contains(p: PyObjectLike, key: PyObjectLike) -> int:

return api_binding_base(

API_FUNCS["PyDict_Contains"], _deref_maybe(p), _deref_maybe(key)

)

# PyDict_Copy

@staticmethod

def copy(p: PyObjectLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyDict_Copy"], _deref_maybe(p))

# PyDict_DelItem

@staticmethod

def del_item(p: PyObjectLike, key: PyObjectLike) -> int:

return api_binding_base(

API_FUNCS["PyDict_DelItem"], _deref_maybe(p), _deref_maybe(key)

)

# PyDict_DelItemString

@staticmethod

def del_item_string(p: PyObjectLike, key: StringLike) -> int:

return api_binding_base(

API_FUNCS["PyDict_DelItemString"], _deref_maybe(p), make_string(key)

)

# PyDict_GetItem

@staticmethod

def get_item(p: PyObjectLike, key: PyObjectLike) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyDict_GetItem"], _deref_maybe(p), _deref_maybe(key)

)

# PyDict_GetItemString

@staticmethod

def get_item_string(p: PyObjectLike, key: StringLike) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyDict_GetItemString"], _deref_maybe(p), make_string(key)

)

# PyDict_GetItemWithError

@staticmethod

def get_item_with_error(p: PyObjectLike, key: PyObjectLike) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyDict_GetItemWithError"], _deref_maybe(p), _deref_maybe(key)

)

# PyDict_Items

@staticmethod

def items(p: PyObjectLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyDict_Items"], _deref_maybe(p))

# PyDict_Keys

@staticmethod

def keys(p: PyObjectLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyDict_Keys"], _deref_maybe(p))

# PyDict_Merge

@staticmethod

def merge(a: PyObjectLike, b: PyObjectLike, override: int) -> int:

return api_binding_base(

API_FUNCS["PyDict_Merge"], _deref_maybe(a), _deref_maybe(b), override

)

# PyDict_MergeFromSeq2

@staticmethod

def merge_from_seq2(a: PyObjectLike, seq2: PyObjectLike, override: int) -> int:

return api_binding_base(

API_FUNCS["PyDict_MergeFromSeq2"],

_deref_maybe(a),

_deref_maybe(seq2),

override,

)

# PyDict_New

@staticmethod

def new() -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyDict_New"],

)

# PyDict_Next

@staticmethod

def next(

p: PyObjectLike, ppos: PointerLike, pkey: PointerLike, pvalue: PointerLike

) -> int:

return api_binding_base(

API_FUNCS["PyDict_Next"], _deref_maybe(p), ppos, pkey, pvalue

)

# PyDict_SetItem

@staticmethod

def set_item(p: PyObjectLike, key: PyObjectLike, val: PyObjectLike) -> int:

return api_binding_base(

API_FUNCS["PyDict_SetItem"],

_deref_maybe(p),

_deref_maybe(key),

_deref_maybe(val),

)

# PyDict_SetItemString

@staticmethod

def set_item_string(p: PyObjectLike, key: StringLike, val: PyObjectLike) -> int:

return api_binding_base(

API_FUNCS["PyDict_SetItemString"],

_deref_maybe(p),

make_string(key),

_deref_maybe(val),

)

# PyDict_Size

@staticmethod

def size(p: PyObjectLike) -> int:

return api_binding_base(API_FUNCS["PyDict_Size"], _deref_maybe(p))

# PyDict_Update

@staticmethod

def update(a: PyObjectLike, b: PyObjectLike) -> int:

return api_binding_base(

API_FUNCS["PyDict_Update"], _deref_maybe(a), _deref_maybe(b)

)

# PyDict_Values

@staticmethod

def values(p: PyObjectLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyDict_Values"], _deref_maybe(p))

class PyErr(_CallBase):

"""Namespace containing API functions prefixed with `PyErr_`"""

# PyErr_BadArgument

@staticmethod

def bad_argument() -> int:

return api_binding_base(

API_FUNCS["PyErr_BadArgument"],

)

# PyErr_BadInternalCall

@staticmethod

def bad_internal_call() -> None:

return api_binding_base(

API_FUNCS["PyErr_BadInternalCall"],

)

# PyErr_CheckSignals

@staticmethod

def check_signals() -> int:

return api_binding_base(

API_FUNCS["PyErr_CheckSignals"],

)

# PyErr_Clear

@staticmethod

def clear() -> None:

return api_binding_base(

API_FUNCS["PyErr_Clear"],

)

# PyErr_ExceptionMatches

@staticmethod

def exception_matches(exc: PyObjectLike) -> int:

return api_binding_base(API_FUNCS["PyErr_ExceptionMatches"], _deref_maybe(exc))

# PyErr_Fetch

@staticmethod

def fetch(ptype: PointerLike, pvalue: PointerLike, ptraceback: PointerLike) -> None:

return api_binding_base(API_FUNCS["PyErr_Fetch"], ptype, pvalue, ptraceback)

# PyErr_FormatV

@staticmethod

def format_v(

exception: PyObjectLike, format: StringLike, vargs: PointerLike

) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyErr_FormatV"],

_deref_maybe(exception),

make_string(format),

vargs,

)

# PyErr_GetExcInfo

@staticmethod

def get_exc_info(

ptype: PointerLike, pvalue: PointerLike, ptraceback: PointerLike

) -> None:

return api_binding_base(

API_FUNCS["PyErr_GetExcInfo"], ptype, pvalue, ptraceback

)

# PyErr_GivenExceptionMatches

@staticmethod

def given_exception_matches(given: PyObjectLike, exc: PyObjectLike) -> int:

return api_binding_base(

API_FUNCS["PyErr_GivenExceptionMatches"],

_deref_maybe(given),

_deref_maybe(exc),

)

# PyErr_NewException

@staticmethod

def new_exception(

name: StringLike, base: PyObjectLike, dict: PyObjectLike

) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyErr_NewException"],

make_string(name),

_deref_maybe(base),

_deref_maybe(dict),

)

# PyErr_NewExceptionWithDoc

@staticmethod

def new_exception_with_doc(

name: StringLike, doc: StringLike, base: PyObjectLike, dict: PyObjectLike

) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyErr_NewExceptionWithDoc"],

make_string(name),

make_string(doc),

_deref_maybe(base),

_deref_maybe(dict),

)

# PyErr_NoMemory

@staticmethod

def no_memory() -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyErr_NoMemory"],

)

# PyErr_NormalizeException

@staticmethod

def normalize_exception(

exc: PointerLike, val: PointerLike, tb: PointerLike

) -> None:

return api_binding_base(API_FUNCS["PyErr_NormalizeException"], exc, val, tb)

# PyErr_Occurred

@staticmethod

def occurred() -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyErr_Occurred"],

)

# PyErr_Print

@staticmethod

def print() -> None:

return api_binding_base(

API_FUNCS["PyErr_Print"],

)

# PyErr_PrintEx

@staticmethod

def print_ex(set_sys_last_vars: int) -> None:

return api_binding_base(API_FUNCS["PyErr_PrintEx"], set_sys_last_vars)

# PyErr_Restore

@staticmethod

def restore(

type: PyObjectLike, value: PyObjectLike, traceback: PyObjectLike

) -> None:

return api_binding_base(

API_FUNCS["PyErr_Restore"],

_deref_maybe(type),

_deref_maybe(value),

_deref_maybe(traceback),

)

# PyErr_SetExcInfo

@staticmethod

def set_exc_info(

type: PyObjectLike, value: PyObjectLike, traceback: PyObjectLike

) -> None:

return api_binding_base(

API_FUNCS["PyErr_SetExcInfo"],

_deref_maybe(type),

_deref_maybe(value),

_deref_maybe(traceback),

)

# PyErr_SetFromErrno

@staticmethod

def set_from_errno(type: PyObjectLike) -> PyObjectLike:

return api_binding_base(API_FUNCS["PyErr_SetFromErrno"], _deref_maybe(type))

# PyErr_SetFromErrnoWithFilename

@staticmethod

def set_from_errno_with_filename(

type: PyObjectLike, filename: StringLike

) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyErr_SetFromErrnoWithFilename"],

_deref_maybe(type),

make_string(filename),

)

# PyErr_SetFromErrnoWithFilenameObject

@staticmethod

def set_from_errno_with_filename_object(

type: PyObjectLike, filenameObject: PyObjectLike

) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyErr_SetFromErrnoWithFilenameObject"],

_deref_maybe(type),

_deref_maybe(filenameObject),

)

# PyErr_SetFromErrnoWithFilenameObjects

@staticmethod

def set_from_errno_with_filename_objects(

type: PyObjectLike, filenameObject: PyObjectLike, filenameObject2: PyObjectLike

) -> PyObjectLike:

return api_binding_base(

API_FUNCS["PyErr_SetFromErrnoWithFilenameObjects"],

_deref_maybe(type),

_deref_maybe(filenameObject),

_deref_maybe(filenameObject2),

)