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),
)
# PyErr_SetImportError
@staticmethod
def set_import_error(
msg: PyObjectLike, name: PyObjectLike, path: PyObjectLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyErr_SetImportError"],
_deref_maybe(msg),
_deref_maybe(name),
_deref_maybe(path),
)
# PyErr_SetImportErrorSubclass
@staticmethod
def set_import_error_subclass(
exception: PyObjectLike,
msg: PyObjectLike,
name: PyObjectLike,
path: PyObjectLike,
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyErr_SetImportErrorSubclass"],
_deref_maybe(exception),
_deref_maybe(msg),
_deref_maybe(name),
_deref_maybe(path),
)
# PyErr_SetInterrupt
@staticmethod
def set_interrupt() -> None:
return api_binding_base(
API_FUNCS["PyErr_SetInterrupt"],
)
# PyErr_SetInterruptEx
@staticmethod
def set_interrupt_ex(signum: int) -> int:
return api_binding_base(API_FUNCS["PyErr_SetInterruptEx"], signum)
# PyErr_SetNone
@staticmethod
def set_none(type: PyObjectLike) -> None:
return api_binding_base(API_FUNCS["PyErr_SetNone"], _deref_maybe(type))
# PyErr_SetObject
@staticmethod
def set_object(type: PyObjectLike, value: PyObjectLike) -> None:
return api_binding_base(
API_FUNCS["PyErr_SetObject"], _deref_maybe(type), _deref_maybe(value)
)
# PyErr_SetString
@staticmethod
def set_string(type: PyObjectLike, message: StringLike) -> None:
return api_binding_base(
API_FUNCS["PyErr_SetString"], _deref_maybe(type), make_string(message)
)
# PyErr_SyntaxLocation
@staticmethod
def syntax_location(filename: StringLike, lineno: int) -> None:
return api_binding_base(
API_FUNCS["PyErr_SyntaxLocation"], make_string(filename), lineno
)
# PyErr_SyntaxLocationEx
@staticmethod
def syntax_location_ex(filename: StringLike, lineno: int, col_offset: int) -> None:
return api_binding_base(
API_FUNCS["PyErr_SyntaxLocationEx"],
make_string(filename),
lineno,
col_offset,
)
# PyErr_WarnEx
@staticmethod
def warn_ex(category: PyObjectLike, message: StringLike, stack_level: int) -> int:
return api_binding_base(
API_FUNCS["PyErr_WarnEx"],
_deref_maybe(category),
make_string(message),
stack_level,
)
# PyErr_WarnExplicit
@staticmethod
def warn_explicit(
category: PyObjectLike,
message: StringLike,
filename: StringLike,
lineno: int,
module: StringLike,
registry: PyObjectLike,
) -> int:
return api_binding_base(
API_FUNCS["PyErr_WarnExplicit"],
_deref_maybe(category),
make_string(message),
make_string(filename),
lineno,
make_string(module),
_deref_maybe(registry),
)
# PyErr_WriteUnraisable
@staticmethod
def write_unraisable(obj: PyObjectLike) -> None:
return api_binding_base(API_FUNCS["PyErr_WriteUnraisable"], _deref_maybe(obj))
class PyEval(_CallBase):
"""Namespace containing API functions prefixed with `PyEval_`"""
# PyEval_AcquireLock
@staticmethod
def acquire_lock() -> None:
return api_binding_base(
API_FUNCS["PyEval_AcquireLock"],
)
# PyEval_AcquireThread
@staticmethod
def acquire_thread(tstate: StructPointer[ThreadState]) -> None:
return api_binding_base(API_FUNCS["PyEval_AcquireThread"], tstate)
# PyEval_EvalCode
@staticmethod
def eval_code(
co: PyObjectLike, globals: PyObjectLike, locals: PyObjectLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyEval_EvalCode"],
_deref_maybe(co),
_deref_maybe(globals),
_deref_maybe(locals),
)
# PyEval_EvalCodeEx
@staticmethod
def eval_code_ex(
co: PyObjectLike,
globals: PyObjectLike,
locals: PyObjectLike,
args: PointerLike,
argcount: int,
kws: PointerLike,
kwcount: int,
defs: PointerLike,
defcount: int,
kwdefs: PyObjectLike,
closure: PyObjectLike,
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyEval_EvalCodeEx"],
_deref_maybe(co),
_deref_maybe(globals),
_deref_maybe(locals),
args,
argcount,
kws,
kwcount,
defs,
defcount,
_deref_maybe(kwdefs),
_deref_maybe(closure),
)
# PyEval_EvalFrame
@staticmethod
def eval_frame(f: StructPointer[FrameObject]) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyEval_EvalFrame"], f)
# PyEval_EvalFrameEx
@staticmethod
def eval_frame_ex(f: StructPointer[FrameObject], throwflag: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyEval_EvalFrameEx"], f, throwflag)
# PyEval_GetBuiltins
@staticmethod
def get_builtins() -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyEval_GetBuiltins"],
)
# PyEval_GetFrame
@staticmethod
def get_frame() -> StructPointer[FrameObject]:
return api_binding_base(
API_FUNCS["PyEval_GetFrame"],
)
# PyEval_GetFuncDesc
@staticmethod
def get_func_desc(func: PyObjectLike) -> StringLike:
return api_binding_base(API_FUNCS["PyEval_GetFuncDesc"], _deref_maybe(func))
# PyEval_GetFuncName
@staticmethod
def get_func_name(func: PyObjectLike) -> StringLike:
return api_binding_base(API_FUNCS["PyEval_GetFuncName"], _deref_maybe(func))
# PyEval_GetGlobals
@staticmethod
def get_globals() -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyEval_GetGlobals"],
)
# PyEval_GetLocals
@staticmethod
def get_locals() -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyEval_GetLocals"],
)
# PyEval_InitThreads
@staticmethod
def init_threads() -> None:
return api_binding_base(
API_FUNCS["PyEval_InitThreads"],
)
# PyEval_ReleaseLock
@staticmethod
def release_lock() -> None:
return api_binding_base(
API_FUNCS["PyEval_ReleaseLock"],
)
# PyEval_ReleaseThread
@staticmethod
def release_thread(tstate: StructPointer[ThreadState]) -> None:
return api_binding_base(API_FUNCS["PyEval_ReleaseThread"], tstate)
# PyEval_RestoreThread
@staticmethod
def restore_thread(tstate: StructPointer[ThreadState]) -> None:
return api_binding_base(API_FUNCS["PyEval_RestoreThread"], tstate)
# PyEval_SaveThread
@staticmethod
def save_thread() -> StructPointer[ThreadState]:
return api_binding_base(
API_FUNCS["PyEval_SaveThread"],
)
# PyEval_ThreadsInitialized
@staticmethod
def threads_initialized() -> int:
return api_binding_base(
API_FUNCS["PyEval_ThreadsInitialized"],
)
# PyEval_MergeCompilerFlags
@staticmethod
def merge_compiler_flags() -> int:
return api_binding_base(
API_FUNCS["PyEval_MergeCompilerFlags"],
)
class PyException(_CallBase):
"""Namespace containing API functions prefixed with `PyException_`"""
# PyException_GetCause
@staticmethod
def get_cause(ex: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyException_GetCause"], _deref_maybe(ex))
# PyException_GetContext
@staticmethod
def get_context(ex: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyException_GetContext"], _deref_maybe(ex))
# PyException_GetTraceback
@staticmethod
def get_traceback(ex: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyException_GetTraceback"], _deref_maybe(ex))
# PyException_SetCause
@staticmethod
def set_cause(ex: PyObjectLike, cause: PyObjectLike) -> None:
return api_binding_base(
API_FUNCS["PyException_SetCause"], _deref_maybe(ex), _deref_maybe(cause)
)
# PyException_SetContext
@staticmethod
def set_context(ex: PyObjectLike, ctx: PyObjectLike) -> None:
return api_binding_base(
API_FUNCS["PyException_SetContext"], _deref_maybe(ex), _deref_maybe(ctx)
)
# PyException_SetTraceback
@staticmethod
def set_traceback(ex: PyObjectLike, tb: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyException_SetTraceback"], _deref_maybe(ex), _deref_maybe(tb)
)
class PyFile(_CallBase):
"""Namespace containing API functions prefixed with `PyFile_`"""
# PyFile_FromFd
@staticmethod
def from_fd(
fd: int,
name: StringLike,
mode: StringLike,
buffering: int,
encoding: StringLike,
errors: StringLike,
newline: StringLike,
closefd: int,
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyFile_FromFd"],
fd,
make_string(name),
make_string(mode),
buffering,
make_string(encoding),
make_string(errors),
make_string(newline),
closefd,
)
# PyFile_GetLine
@staticmethod
def get_line(p: PyObjectLike, n: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyFile_GetLine"], _deref_maybe(p), n)
# PyFile_WriteObject
@staticmethod
def write_object(obj: PyObjectLike, p: PyObjectLike, flags: int) -> int:
return api_binding_base(
API_FUNCS["PyFile_WriteObject"], _deref_maybe(obj), _deref_maybe(p), flags
)
# PyFile_WriteString
@staticmethod
def write_string(s: StringLike, p: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyFile_WriteString"], make_string(s), _deref_maybe(p)
)
# PyFile_OpenCode
@staticmethod
def open_code(utf8path: StringLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyFile_OpenCode"], make_string(utf8path))
# PyFile_OpenCodeObject
@staticmethod
def open_code_object(path: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyFile_OpenCodeObject"], _deref_maybe(path))
# PyFile_SetOpenCodeHook
@staticmethod
def set_open_code_hook(hook: PointerLike) -> int:
return api_binding_base(API_FUNCS["PyFile_SetOpenCodeHook"], hook)
class PyFloat(_CallBase):
"""Namespace containing API functions prefixed with `PyFloat_`"""
# PyFloat_AsDouble
@staticmethod
def as_double(pyfloat: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyFloat_AsDouble"], _deref_maybe(pyfloat))
# PyFloat_FromDouble
@staticmethod
def from_double(v: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyFloat_FromDouble"], v)
# PyFloat_FromString
@staticmethod
def from_string(str: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyFloat_FromString"], _deref_maybe(str))
# PyFloat_GetInfo
@staticmethod
def get_info() -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyFloat_GetInfo"],
)
# PyFloat_GetMax
@staticmethod
def get_max() -> int:
return api_binding_base(
API_FUNCS["PyFloat_GetMax"],
)
# PyFloat_GetMin
@staticmethod
def get_min() -> int:
return api_binding_base(
API_FUNCS["PyFloat_GetMin"],
)
class PyFrame(_CallBase):
"""Namespace containing API functions prefixed with `PyFrame_`"""
# PyFrame_GetCode
@staticmethod
def get_code(frame: StructPointer[FrameObject]) -> StructPointer[CodeObject]:
return api_binding_base(API_FUNCS["PyFrame_GetCode"], frame)
# PyFrame_GetLineNumber
@staticmethod
def get_line_number(frame: StructPointer[FrameObject]) -> int:
return api_binding_base(API_FUNCS["PyFrame_GetLineNumber"], frame)
# PyFrame_LocalsToFast
@staticmethod
def locals_to_fast(f: StructPointer[FrameObject], i: int) -> None:
return api_binding_base(API_FUNCS["PyFrame_LocalsToFast"], f, i)
# PyFrame_FastToLocalsWithError
@staticmethod
def fast_to_locals_with_error(f: StructPointer[FrameObject]) -> int:
return api_binding_base(API_FUNCS["PyFrame_FastToLocalsWithError"], f)
# PyFrame_GetBack
@staticmethod
def get_back(frame: StructPointer[FrameObject]) -> StructPointer[FrameObject]:
return api_binding_base(API_FUNCS["PyFrame_GetBack"], frame)
class PyFrozenSet(_CallBase):
"""Namespace containing API functions prefixed with `PyFrozenSet_`"""
# PyFrozenSet_New
@staticmethod
def new(iterable: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyFrozenSet_New"], _deref_maybe(iterable))
class PyGC(_CallBase):
"""Namespace containing API functions prefixed with `PyGC_`"""
# PyGC_Collect
@staticmethod
def collect() -> int:
return api_binding_base(
API_FUNCS["PyGC_Collect"],
)
# PyGC_Disable
@staticmethod
def disable() -> int:
return api_binding_base(
API_FUNCS["PyGC_Disable"],
)
# PyGC_Enable
@staticmethod
def enable() -> int:
return api_binding_base(
API_FUNCS["PyGC_Enable"],
)
# PyGC_IsEnabled
@staticmethod
def is_enabled() -> int:
return api_binding_base(
API_FUNCS["PyGC_IsEnabled"],
)
class PyGILState(_CallBase):
"""Namespace containing API functions prefixed with `PyGILState_`"""
# PyGILState_Ensure
@staticmethod
def ensure() -> int:
return api_binding_base(
API_FUNCS["PyGILState_Ensure"],
)
# PyGILState_GetThisThreadState
@staticmethod
def get_this_thread_state() -> StructPointer[ThreadState]:
return api_binding_base(
API_FUNCS["PyGILState_GetThisThreadState"],
)
class PyImport(_CallBase):
"""Namespace containing API functions prefixed with `PyImport_`"""
# PyImport_AddModule
@staticmethod
def add_module(name: StringLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyImport_AddModule"], make_string(name))
# PyImport_AddModuleObject
@staticmethod
def add_module_object(name: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyImport_AddModuleObject"], _deref_maybe(name)
)
# PyImport_ExecCodeModule
@staticmethod
def exec_code_module(name: StringLike, co: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyImport_ExecCodeModule"], make_string(name), _deref_maybe(co)
)
# PyImport_ExecCodeModuleEx
@staticmethod
def exec_code_module_ex(
name: StringLike, co: PyObjectLike, pathname: StringLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyImport_ExecCodeModuleEx"],
make_string(name),
_deref_maybe(co),
make_string(pathname),
)
# PyImport_ExecCodeModuleObject
@staticmethod
def exec_code_module_object(
name: PyObjectLike,
co: PyObjectLike,
pathname: PyObjectLike,
cpathname: PyObjectLike,
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyImport_ExecCodeModuleObject"],
_deref_maybe(name),
_deref_maybe(co),
_deref_maybe(pathname),
_deref_maybe(cpathname),
)
# PyImport_ExecCodeModuleWithPathnames
@staticmethod
def exec_code_module_with_pathnames(
name: StringLike, co: PyObjectLike, pathname: StringLike, cpathname: StringLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyImport_ExecCodeModuleWithPathnames"],
make_string(name),
_deref_maybe(co),
make_string(pathname),
make_string(cpathname),
)
# PyImport_GetImporter
@staticmethod
def get_importer(path: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyImport_GetImporter"], _deref_maybe(path))
# PyImport_GetMagicNumber
@staticmethod
def get_magic_number() -> int:
return api_binding_base(
API_FUNCS["PyImport_GetMagicNumber"],
)
# PyImport_GetMagicTag
@staticmethod
def get_magic_tag() -> StringLike:
return api_binding_base(
API_FUNCS["PyImport_GetMagicTag"],
)
# PyImport_GetModule
@staticmethod
def get_module(name: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyImport_GetModule"], _deref_maybe(name))
# PyImport_GetModuleDict
@staticmethod
def get_module_dict() -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyImport_GetModuleDict"],
)
# PyImport_Import
@staticmethod
def import_(name: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyImport_Import"], _deref_maybe(name))
# PyImport_ImportFrozenModule
@staticmethod
def import_frozen_module(name: StringLike) -> int:
return api_binding_base(
API_FUNCS["PyImport_ImportFrozenModule"], make_string(name)
)
# PyImport_ImportFrozenModuleObject
@staticmethod
def import_frozen_module_object(name: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyImport_ImportFrozenModuleObject"], _deref_maybe(name)
)
# PyImport_ImportModule
@staticmethod
def import_module(name: StringLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyImport_ImportModule"], make_string(name))
# PyImport_ImportModuleLevel
@staticmethod
def import_module_level(
name: StringLike,
globals: PyObjectLike,
locals: PyObjectLike,
fromlist: PyObjectLike,
level: int,
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyImport_ImportModuleLevel"],
make_string(name),
_deref_maybe(globals),
_deref_maybe(locals),
_deref_maybe(fromlist),
level,
)
# PyImport_ImportModuleLevelObject
@staticmethod
def import_module_level_object(
name: PyObjectLike,
globals: PyObjectLike,
locals: PyObjectLike,
fromlist: PyObjectLike,
level: int,
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyImport_ImportModuleLevelObject"],
_deref_maybe(name),
_deref_maybe(globals),
_deref_maybe(locals),
_deref_maybe(fromlist),
level,
)
# PyImport_ImportModuleNoBlock
@staticmethod
def import_module_no_block(name: StringLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyImport_ImportModuleNoBlock"], make_string(name)
)
# PyImport_ReloadModule
@staticmethod
def reload_module(m: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyImport_ReloadModule"], _deref_maybe(m))
class PyIndex(_CallBase):
"""Namespace containing API functions prefixed with `PyIndex_`"""
# PyIndex_Check
@staticmethod
def check(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyIndex_Check"], _deref_maybe(o))
class PyInterpreterState(_CallBase):
"""Namespace containing API functions prefixed with `PyInterpreterState_`"""
# PyInterpreterState_Clear
@staticmethod
def clear(interp: StructPointer[InterpreterState]) -> None:
return api_binding_base(API_FUNCS["PyInterpreterState_Clear"], interp)
# PyInterpreterState_Delete
@staticmethod
def delete(interp: StructPointer[InterpreterState]) -> None:
return api_binding_base(API_FUNCS["PyInterpreterState_Delete"], interp)
# PyInterpreterState_Get
@staticmethod
def get() -> StructPointer[InterpreterState]:
return api_binding_base(
API_FUNCS["PyInterpreterState_Get"],
)
# PyInterpreterState_GetDict
@staticmethod
def get_dict(interp: StructPointer[InterpreterState]) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyInterpreterState_GetDict"], interp)
# PyInterpreterState_GetID
@staticmethod
def get_i_d(interp: StructPointer[InterpreterState]) -> int:
return api_binding_base(API_FUNCS["PyInterpreterState_GetID"], interp)
# PyInterpreterState_New
@staticmethod
def new() -> StructPointer[InterpreterState]:
return api_binding_base(
API_FUNCS["PyInterpreterState_New"],
)
class PyIter(_CallBase):
"""Namespace containing API functions prefixed with `PyIter_`"""
# PyIter_Check
@staticmethod
def check(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyIter_Check"], _deref_maybe(o))
# PyIter_Next
@staticmethod
def next(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyIter_Next"], _deref_maybe(o))
# PyIter_Send
@staticmethod
def send(iter: PyObjectLike, arg: PyObjectLike, presult: PointerLike) -> int:
return api_binding_base(
API_FUNCS["PyIter_Send"], _deref_maybe(iter), _deref_maybe(arg), presult
)
class PyList(_CallBase):
"""Namespace containing API functions prefixed with `PyList_`"""
# PyList_Append
@staticmethod
def append(list: PyObjectLike, item: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyList_Append"], _deref_maybe(list), _deref_maybe(item)
)
# PyList_AsTuple
@staticmethod
def as_tuple(list: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyList_AsTuple"], _deref_maybe(list))
# PyList_GetItem
@staticmethod
def get_item(list: PyObjectLike, index: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyList_GetItem"], _deref_maybe(list), index)
# PyList_GetSlice
@staticmethod
def get_slice(list: PyObjectLike, low: int, high: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyList_GetSlice"], _deref_maybe(list), low, high
)
# PyList_Insert
@staticmethod
def insert(list: PyObjectLike, index: int, item: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyList_Insert"], _deref_maybe(list), index, _deref_maybe(item)
)
# PyList_New
@staticmethod
def new(len: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyList_New"], len)
# PyList_Reverse
@staticmethod
def reverse(list: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyList_Reverse"], _deref_maybe(list))
# PyList_SetItem
@staticmethod
def set_item(list: PyObjectLike, index: int, item: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyList_SetItem"], _deref_maybe(list), index, _deref_maybe(item)
)
# PyList_SetSlice
@staticmethod
def set_slice(
list: PyObjectLike, low: int, high: int, itemlist: PyObjectLike
) -> int:
return api_binding_base(
API_FUNCS["PyList_SetSlice"],
_deref_maybe(list),
low,
high,
_deref_maybe(itemlist),
)
# PyList_Size
@staticmethod
def size(list: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyList_Size"], _deref_maybe(list))
# PyList_Sort
@staticmethod
def sort(list: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyList_Sort"], _deref_maybe(list))
class PyLong(_CallBase):
"""Namespace containing API functions prefixed with `PyLong_`"""
# PyLong_AsDouble
@staticmethod
def as_double(pylong: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyLong_AsDouble"], _deref_maybe(pylong))
# PyLong_AsLong
@staticmethod
def as_long(obj: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyLong_AsLong"], _deref_maybe(obj))
# PyLong_AsLongAndOverflow
@staticmethod
def as_long_and_overflow(obj: PyObjectLike, overflow: PointerLike) -> int:
return api_binding_base(
API_FUNCS["PyLong_AsLongAndOverflow"], _deref_maybe(obj), overflow
)
# PyLong_AsLongLong
@staticmethod
def as_long_long(obj: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyLong_AsLongLong"], _deref_maybe(obj))
# PyLong_AsLongLongAndOverflow
@staticmethod
def as_long_long_and_overflow(obj: PyObjectLike, overflow: PointerLike) -> int:
return api_binding_base(
API_FUNCS["PyLong_AsLongLongAndOverflow"], _deref_maybe(obj), overflow
)
# PyLong_AsSize_t
@staticmethod
def as_size_t(pylong: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyLong_AsSize_t"], _deref_maybe(pylong))
# PyLong_AsSsize_t
@staticmethod
def as_ssize_t(pylong: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyLong_AsSsize_t"], _deref_maybe(pylong))
# PyLong_AsUnsignedLong
@staticmethod
def as_unsigned_long(pylong: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyLong_AsUnsignedLong"], _deref_maybe(pylong)
)
# PyLong_AsUnsignedLongLong
@staticmethod
def as_unsigned_long_long(pylong: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyLong_AsUnsignedLongLong"], _deref_maybe(pylong)
)
# PyLong_AsUnsignedLongLongMask
@staticmethod
def as_unsigned_long_long_mask(obj: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyLong_AsUnsignedLongLongMask"], _deref_maybe(obj)
)
# PyLong_AsUnsignedLongMask
@staticmethod
def as_unsigned_long_mask(obj: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyLong_AsUnsignedLongMask"], _deref_maybe(obj)
)
# PyLong_AsVoidPtr
@staticmethod
def as_void_ptr(pylong: PyObjectLike) -> PointerLike:
return api_binding_base(API_FUNCS["PyLong_AsVoidPtr"], _deref_maybe(pylong))
# PyLong_FromDouble
@staticmethod
def from_double(v: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyLong_FromDouble"], v)
# PyLong_FromLong
@staticmethod
def from_long(v: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyLong_FromLong"], v)
# PyLong_FromLongLong
@staticmethod
def from_long_long(v: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyLong_FromLongLong"], v)
# PyLong_FromSize_t
@staticmethod
def from_size_t(v: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyLong_FromSize_t"], v)
# PyLong_FromSsize_t
@staticmethod
def from_ssize_t(v: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyLong_FromSsize_t"], v)
# PyLong_FromString
@staticmethod
def from_string(str: StringLike, pend: PointerLike, base: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyLong_FromString"], make_string(str), pend, base
)
# PyLong_FromUnsignedLong
@staticmethod
def from_unsigned_long(v: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyLong_FromUnsignedLong"], v)
# PyLong_FromUnsignedLongLong
@staticmethod
def from_unsigned_long_long(v: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyLong_FromUnsignedLongLong"], v)
# PyLong_FromVoidPtr
@staticmethod
def from_void_ptr(p: PointerLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyLong_FromVoidPtr"], p)
class PyMapping(_CallBase):
"""Namespace containing API functions prefixed with `PyMapping_`"""
# PyMapping_Check
@staticmethod
def check(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyMapping_Check"], _deref_maybe(o))
# PyMapping_GetItemString
@staticmethod
def get_item_string(o: PyObjectLike, key: StringLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyMapping_GetItemString"], _deref_maybe(o), make_string(key)
)
# PyMapping_HasKey
@staticmethod
def has_key(o: PyObjectLike, key: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyMapping_HasKey"], _deref_maybe(o), _deref_maybe(key)
)
# PyMapping_HasKeyString
@staticmethod
def has_key_string(o: PyObjectLike, key: StringLike) -> int:
return api_binding_base(
API_FUNCS["PyMapping_HasKeyString"], _deref_maybe(o), make_string(key)
)
# PyMapping_Items
@staticmethod
def items(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyMapping_Items"], _deref_maybe(o))
# PyMapping_Keys
@staticmethod
def keys(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyMapping_Keys"], _deref_maybe(o))
# PyMapping_Length
@staticmethod
def length(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyMapping_Length"], _deref_maybe(o))
# PyMapping_SetItemString
@staticmethod
def set_item_string(o: PyObjectLike, key: StringLike, v: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyMapping_SetItemString"],
_deref_maybe(o),
make_string(key),
_deref_maybe(v),
)
# PyMapping_Size
@staticmethod
def size(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyMapping_Size"], _deref_maybe(o))
# PyMapping_Values
@staticmethod
def values(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyMapping_Values"], _deref_maybe(o))
class PyMem(_CallBase):
"""Namespace containing API functions prefixed with `PyMem_`"""
# PyMem_Calloc
@staticmethod
def calloc(nelem: int, elsize: int) -> PointerLike:
return api_binding_base(API_FUNCS["PyMem_Calloc"], nelem, elsize)
# PyMem_Free
@staticmethod
def free(p: PointerLike) -> None:
return api_binding_base(API_FUNCS["PyMem_Free"], p)
# PyMem_Malloc
@staticmethod
def malloc(n: int) -> PointerLike:
return api_binding_base(API_FUNCS["PyMem_Malloc"], n)
# PyMem_Realloc
@staticmethod
def realloc(p: PointerLike, n: int) -> PointerLike:
return api_binding_base(API_FUNCS["PyMem_Realloc"], p, n)
# PyMem_RawMalloc
@staticmethod
def raw_malloc(size: int) -> PointerLike:
return api_binding_base(API_FUNCS["PyMem_RawMalloc"], size)
# PyMem_RawCalloc
@staticmethod
def raw_calloc(nelem: int, elsize: int) -> PointerLike:
return api_binding_base(API_FUNCS["PyMem_RawCalloc"], nelem, elsize)
# PyMem_RawRealloc
@staticmethod
def raw_realloc(ptr: PointerLike, new_size: int) -> PointerLike:
return api_binding_base(API_FUNCS["PyMem_RawRealloc"], ptr, new_size)
# PyMem_RawFree
@staticmethod
def raw_free(ptr: PointerLike) -> None:
return api_binding_base(API_FUNCS["PyMem_RawFree"], ptr)
# PyMem_SetupDebugHooks
@staticmethod
def setup_debug_hooks() -> None:
return api_binding_base(
API_FUNCS["PyMem_SetupDebugHooks"],
)
class PyMemoryView(_CallBase):
"""Namespace containing API functions prefixed with `PyMemoryView_`"""
# PyMemoryView_FromBuffer
@staticmethod
def from_buffer(view: StructPointer[Buffer]) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyMemoryView_FromBuffer"], view)
# PyMemoryView_FromMemory
@staticmethod
def from_memory(mem: StringLike, size: int, flags: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyMemoryView_FromMemory"], make_string(mem), size, flags
)
# PyMemoryView_FromObject
@staticmethod
def from_object(obj: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyMemoryView_FromObject"], _deref_maybe(obj))
# PyMemoryView_GetContiguous
@staticmethod
def get_contiguous(
obj: PyObjectLike, buffertype: int, order: CharLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyMemoryView_GetContiguous"],
_deref_maybe(obj),
buffertype,
make_char(order),
)
class PyModuleDef(_CallBase):
"""Namespace containing API functions prefixed with `PyModuleDef_`"""
# PyModuleDef_Init
@staticmethod
def init(df: StructPointer[ModuleDef]) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyModuleDef_Init"], df)
class PyModule(_CallBase):
"""Namespace containing API functions prefixed with `PyModule_`"""
# PyModule_AddFunctions
@staticmethod
def add_functions(module: PyObjectLike, functions: StructPointer[MethodDef]) -> int:
return api_binding_base(
API_FUNCS["PyModule_AddFunctions"], _deref_maybe(module), functions
)
# PyModule_AddIntConstant
@staticmethod
def add_int_constant(module: PyObjectLike, name: StringLike, value: int) -> int:
return api_binding_base(
API_FUNCS["PyModule_AddIntConstant"],
_deref_maybe(module),
make_string(name),
value,
)
# PyModule_AddObject
@staticmethod
def add_object(module: PyObjectLike, name: StringLike, value: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyModule_AddObject"],
_deref_maybe(module),
make_string(name),
_deref_maybe(value),
)
# PyModule_AddObjectRef
@staticmethod
def add_object_ref(
module: PyObjectLike, name: StringLike, value: PyObjectLike
) -> int:
return api_binding_base(
API_FUNCS["PyModule_AddObjectRef"],
_deref_maybe(module),
make_string(name),
_deref_maybe(value),
)
# PyModule_AddStringConstant
@staticmethod
def add_string_constant(
module: PyObjectLike, name: StringLike, value: StringLike
) -> int:
return api_binding_base(
API_FUNCS["PyModule_AddStringConstant"],
_deref_maybe(module),
make_string(name),
make_string(value),
)
# PyModule_AddType
@staticmethod
def add_type(module: PyObjectLike, type: StructPointer[TypeObject]) -> int:
return api_binding_base(
API_FUNCS["PyModule_AddType"], _deref_maybe(module), type
)
# PyModule_Create2
@staticmethod
def create2(df: StructPointer[ModuleDef], module_api_version: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyModule_Create2"], df, module_api_version)
# PyModule_ExecDef
@staticmethod
def exec_def(module: PyObjectLike, df: StructPointer[ModuleDef]) -> int:
return api_binding_base(API_FUNCS["PyModule_ExecDef"], _deref_maybe(module), df)
# PyModule_FromDefAndSpec2
@staticmethod
def from_def_and_spec2(
df: StructPointer[ModuleDef], spec: PyObjectLike, module_api_version: int
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyModule_FromDefAndSpec2"],
df,
_deref_maybe(spec),
module_api_version,
)
# PyModule_GetDef
@staticmethod
def get_def(module: PyObjectLike) -> StructPointer[ModuleDef]:
return api_binding_base(API_FUNCS["PyModule_GetDef"], _deref_maybe(module))
# PyModule_GetDict
@staticmethod
def get_dict(module: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyModule_GetDict"], _deref_maybe(module))
# PyModule_GetFilename
@staticmethod
def get_filename(module: PyObjectLike) -> StringLike:
return api_binding_base(API_FUNCS["PyModule_GetFilename"], _deref_maybe(module))
# PyModule_GetFilenameObject
@staticmethod
def get_filename_object(module: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyModule_GetFilenameObject"], _deref_maybe(module)
)
# PyModule_GetName
@staticmethod
def get_name(module: PyObjectLike) -> StringLike:
return api_binding_base(API_FUNCS["PyModule_GetName"], _deref_maybe(module))
# PyModule_GetNameObject
@staticmethod
def get_name_object(module: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyModule_GetNameObject"], _deref_maybe(module)
)
# PyModule_GetState
@staticmethod
def get_state(module: PyObjectLike) -> PointerLike:
return api_binding_base(API_FUNCS["PyModule_GetState"], _deref_maybe(module))
# PyModule_New
@staticmethod
def new(name: StringLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyModule_New"], make_string(name))
# PyModule_NewObject
@staticmethod
def new_object(name: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyModule_NewObject"], _deref_maybe(name))
# PyModule_SetDocString
@staticmethod
def set_doc_string(module: PyObjectLike, docstring: StringLike) -> int:
return api_binding_base(
API_FUNCS["PyModule_SetDocString"],
_deref_maybe(module),
make_string(docstring),
)
class PyNumber(_CallBase):
"""Namespace containing API functions prefixed with `PyNumber_`"""
# PyNumber_Absolute
@staticmethod
def absolute(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyNumber_Absolute"], _deref_maybe(o))
# PyNumber_Add
@staticmethod
def add(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_Add"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_And
@staticmethod
def and_(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_And"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_AsSsize_t
@staticmethod
def as_ssize_t(o: PyObjectLike, exc: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyNumber_AsSsize_t"], _deref_maybe(o), _deref_maybe(exc)
)
# PyNumber_Check
@staticmethod
def check(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyNumber_Check"], _deref_maybe(o))
# PyNumber_Divmod
@staticmethod
def divmod(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_Divmod"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_Float
@staticmethod
def float(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyNumber_Float"], _deref_maybe(o))
# PyNumber_FloorDivide
@staticmethod
def floor_divide(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_FloorDivide"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_InPlaceAdd
@staticmethod
def in_place_add(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_InPlaceAdd"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_InPlaceAnd
@staticmethod
def in_place_and(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_InPlaceAnd"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_InPlaceFloorDivide
@staticmethod
def in_place_floor_divide(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_InPlaceFloorDivide"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_InPlaceLshift
@staticmethod
def in_place_lshift(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_InPlaceLshift"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_InPlaceMatrixMultiply
@staticmethod
def in_place_matrix_multiply(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_InPlaceMatrixMultiply"],
_deref_maybe(o1),
_deref_maybe(o2),
)
# PyNumber_InPlaceMultiply
@staticmethod
def in_place_multiply(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_InPlaceMultiply"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_InPlaceOr
@staticmethod
def in_place_or(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_InPlaceOr"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_InPlacePower
@staticmethod
def in_place_power(
o1: PyObjectLike, o2: PyObjectLike, o3: PyObjectLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_InPlacePower"],
_deref_maybe(o1),
_deref_maybe(o2),
_deref_maybe(o3),
)
# PyNumber_InPlaceRemainder
@staticmethod
def in_place_remainder(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_InPlaceRemainder"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_InPlaceRshift
@staticmethod
def in_place_rshift(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_InPlaceRshift"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_InPlaceSubtract
@staticmethod
def in_place_subtract(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_InPlaceSubtract"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_InPlaceTrueDivide
@staticmethod
def in_place_true_divide(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_InPlaceTrueDivide"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_InPlaceXor
@staticmethod
def in_place_xor(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_InPlaceXor"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_Index
@staticmethod
def index(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyNumber_Index"], _deref_maybe(o))
# PyNumber_Invert
@staticmethod
def invert(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyNumber_Invert"], _deref_maybe(o))
# PyNumber_Long
@staticmethod
def long(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyNumber_Long"], _deref_maybe(o))
# PyNumber_Lshift
@staticmethod
def lshift(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_Lshift"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_MatrixMultiply
@staticmethod
def matrix_multiply(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_MatrixMultiply"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_Multiply
@staticmethod
def multiply(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_Multiply"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_Negative
@staticmethod
def negative(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyNumber_Negative"], _deref_maybe(o))
# PyNumber_Or
@staticmethod
def or_(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_Or"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_Positive
@staticmethod
def positive(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyNumber_Positive"], _deref_maybe(o))
# PyNumber_Power
@staticmethod
def power(o1: PyObjectLike, o2: PyObjectLike, o3: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_Power"],
_deref_maybe(o1),
_deref_maybe(o2),
_deref_maybe(o3),
)
# PyNumber_Remainder
@staticmethod
def remainder(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_Remainder"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_Rshift
@staticmethod
def rshift(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_Rshift"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_Subtract
@staticmethod
def subtract(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_Subtract"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_ToBase
@staticmethod
def to_base(n: PyObjectLike, base: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyNumber_ToBase"], _deref_maybe(n), base)
# PyNumber_TrueDivide
@staticmethod
def true_divide(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_TrueDivide"], _deref_maybe(o1), _deref_maybe(o2)
)
# PyNumber_Xor
@staticmethod
def xor(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyNumber_Xor"], _deref_maybe(o1), _deref_maybe(o2)
)
class PyOS(_CallBase):
"""Namespace containing API functions prefixed with `PyOS_`"""
# PyOS_AfterFork
@staticmethod
def after_fork() -> None:
return api_binding_base(
API_FUNCS["PyOS_AfterFork"],
)
# PyOS_AfterFork_Child
@staticmethod
def after_fork_child() -> None:
return api_binding_base(
API_FUNCS["PyOS_AfterFork_Child"],
)
# PyOS_AfterFork_Parent
@staticmethod
def after_fork_parent() -> None:
return api_binding_base(
API_FUNCS["PyOS_AfterFork_Parent"],
)
# PyOS_BeforeFork
@staticmethod
def before_fork() -> None:
return api_binding_base(
API_FUNCS["PyOS_BeforeFork"],
)
# PyOS_FSPath
@staticmethod
def fs_path(path: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyOS_FSPath"], _deref_maybe(path))
# PyOS_double_to_string
@staticmethod
def double_to_string(
val: int, format_code: CharLike, precision: int, flags: int, ptype: PointerLike
) -> StringLike:
return api_binding_base(
API_FUNCS["PyOS_double_to_string"],
val,
make_char(format_code),
precision,
flags,
ptype,
)
# PyOS_getsig
@staticmethod
def getsig(i: int) -> PointerLike:
return api_binding_base(API_FUNCS["PyOS_getsig"], i)
# PyOS_setsig
@staticmethod
def setsig(i: int, h: PointerLike) -> PointerLike:
return api_binding_base(API_FUNCS["PyOS_setsig"], i, h)
# PyOS_string_to_double
@staticmethod
def string_to_double(
s: StringLike, endptr: PointerLike, overflow_exception: PyObjectLike
) -> int:
return api_binding_base(
API_FUNCS["PyOS_string_to_double"],
make_string(s),
endptr,
_deref_maybe(overflow_exception),
)
# PyOS_vsnprintf
@staticmethod
def vsnprintf(
str: StringLike, size: int, format: StringLike, va: PointerLike
) -> int:
return api_binding_base(
API_FUNCS["PyOS_vsnprintf"], make_string(str), size, make_string(format), va
)
# PyOS_mystrnicmp
@staticmethod
def mystrnicmp(a: StringLike, b: StringLike, c: int) -> int:
return api_binding_base(
API_FUNCS["PyOS_mystrnicmp"], make_string(a), make_string(b), c
)
# PyOS_InterruptOccurred
@staticmethod
def interrupt_occurred() -> int:
return api_binding_base(
API_FUNCS["PyOS_InterruptOccurred"],
)
class PyObject(_CallBase):
"""Namespace containing API functions prefixed with `PyObject_`"""
# PyObject_ASCII
@staticmethod
def ascii(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyObject_ASCII"], _deref_maybe(o))
# PyObject_AsCharBuffer
@staticmethod
def as_char_buffer(
obj: PyObjectLike, buffer: PointerLike, buffer_len: PointerLike
) -> int:
return api_binding_base(
API_FUNCS["PyObject_AsCharBuffer"], _deref_maybe(obj), buffer, buffer_len
)
# PyObject_AsFileDescriptor
@staticmethod
def as_file_descriptor(p: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyObject_AsFileDescriptor"], _deref_maybe(p))
# PyObject_AsReadBuffer
@staticmethod
def as_read_buffer(
obj: PyObjectLike, buffer: PointerLike, buffer_len: PointerLike
) -> int:
return api_binding_base(
API_FUNCS["PyObject_AsReadBuffer"], _deref_maybe(obj), buffer, buffer_len
)
# PyObject_AsWriteBuffer
@staticmethod
def as_write_buffer(
obj: PyObjectLike, buffer: PointerLike, buffer_len: PointerLike
) -> int:
return api_binding_base(
API_FUNCS["PyObject_AsWriteBuffer"], _deref_maybe(obj), buffer, buffer_len
)
# PyObject_Bytes
@staticmethod
def bytes(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyObject_Bytes"], _deref_maybe(o))
# PyObject_Call
@staticmethod
def call(
callable: PyObjectLike, args: PyObjectLike, kwargs: PyObjectLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyObject_Call"],
_deref_maybe(callable),
_deref_maybe(args),
_deref_maybe(kwargs),
)
# PyObject_CallNoArgs
@staticmethod
def call_no_args(callable: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyObject_CallNoArgs"], _deref_maybe(callable)
)
# PyObject_CallObject
@staticmethod
def call_object(callable: PyObjectLike, args: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyObject_CallObject"], _deref_maybe(callable), _deref_maybe(args)
)
# PyObject_Calloc
@staticmethod
def calloc(nelem: int, elsize: int) -> PointerLike:
return api_binding_base(API_FUNCS["PyObject_Calloc"], nelem, elsize)
# PyObject_CheckBuffer
@staticmethod
def check_buffer(obj: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyObject_CheckBuffer"], _deref_maybe(obj))
# PyObject_CheckReadBuffer
@staticmethod
def check_read_buffer(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyObject_CheckReadBuffer"], _deref_maybe(o))
# PyObject_CopyData
@staticmethod
def copy_data(dest: StructPointer[Buffer], src: StructPointer[Buffer]) -> int:
return api_binding_base(API_FUNCS["PyObject_CopyData"], dest, src)
# PyObject_DelItem
@staticmethod
def del_item(o: PyObjectLike, key: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyObject_DelItem"], _deref_maybe(o), _deref_maybe(key)
)
# PyObject_Dir
@staticmethod
def dir(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyObject_Dir"], _deref_maybe(o))
# PyObject_Free
@staticmethod
def free(p: PointerLike) -> None:
return api_binding_base(API_FUNCS["PyObject_Free"], p)
# PyObject_GC_Del
@staticmethod
def gc_del(op: PointerLike) -> None:
return api_binding_base(API_FUNCS["PyObject_GC_Del"], op)
# PyObject_GC_IsFinalized
@staticmethod
def gc_is_finalized(op: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyObject_GC_IsFinalized"], _deref_maybe(op))
# PyObject_GC_IsTracked
@staticmethod
def gc_is_tracked(op: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyObject_GC_IsTracked"], _deref_maybe(op))
# PyObject_GC_Track
@staticmethod
def gc_track(op: PyObjectLike) -> None:
return api_binding_base(API_FUNCS["PyObject_GC_Track"], _deref_maybe(op))
# PyObject_GC_UnTrack
@staticmethod
def gc_untrack(op: PointerLike) -> None:
return api_binding_base(API_FUNCS["PyObject_GC_UnTrack"], op)
# PyObject_GenericGetAttr
@staticmethod
def generic_get_attr(o: PyObjectLike, name: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyObject_GenericGetAttr"], _deref_maybe(o), _deref_maybe(name)
)
# PyObject_GenericGetDict
@staticmethod
def generic_get_dict(o: PyObjectLike, context: PointerLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyObject_GenericGetDict"], _deref_maybe(o), context
)
# PyObject_GenericSetAttr
@staticmethod
def generic_set_attr(
o: PyObjectLike, name: PyObjectLike, value: PyObjectLike
) -> int:
return api_binding_base(
API_FUNCS["PyObject_GenericSetAttr"],
_deref_maybe(o),
_deref_maybe(name),
_deref_maybe(value),
)
# PyObject_GenericSetDict
@staticmethod
def generic_set_dict(
o: PyObjectLike, value: PyObjectLike, context: PointerLike
) -> int:
return api_binding_base(
API_FUNCS["PyObject_GenericSetDict"],
_deref_maybe(o),
_deref_maybe(value),
context,
)
# PyObject_GetAIter
@staticmethod
def get_a_iter(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyObject_GetAIter"], _deref_maybe(o))
# PyObject_GetAttr
@staticmethod
def get_attr(o: PyObjectLike, attr_name: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyObject_GetAttr"], _deref_maybe(o), _deref_maybe(attr_name)
)
# PyObject_GetAttrString
@staticmethod
def get_attr_string(o: PyObjectLike, attr_name: StringLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyObject_GetAttrString"], _deref_maybe(o), make_string(attr_name)
)
# PyObject_GetBuffer
@staticmethod
def get_buffer(
exporter: PyObjectLike, view: StructPointer[Buffer], flags: int
) -> int:
return api_binding_base(
API_FUNCS["PyObject_GetBuffer"], _deref_maybe(exporter), view, flags
)
# PyObject_GetItem
@staticmethod
def get_item(o: PyObjectLike, key: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyObject_GetItem"], _deref_maybe(o), _deref_maybe(key)
)
# PyObject_GetIter
@staticmethod
def get_iter(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyObject_GetIter"], _deref_maybe(o))
# PyObject_HasAttr
@staticmethod
def has_attr(o: PyObjectLike, attr_name: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyObject_HasAttr"], _deref_maybe(o), _deref_maybe(attr_name)
)
# PyObject_HasAttrString
@staticmethod
def has_attr_string(o: PyObjectLike, attr_name: StringLike) -> int:
return api_binding_base(
API_FUNCS["PyObject_HasAttrString"], _deref_maybe(o), make_string(attr_name)
)
# PyObject_Hash
@staticmethod
def hash(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyObject_Hash"], _deref_maybe(o))
# PyObject_HashNotImplemented
@staticmethod
def hash_not_implemented(o: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyObject_HashNotImplemented"], _deref_maybe(o)
)
# PyObject_Init
@staticmethod
def init(op: PyObjectLike, type: StructPointer[TypeObject]) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyObject_Init"], _deref_maybe(op), type)
# PyObject_InitVar
@staticmethod
def init_var(
op: StructPointer[VarObject], type: StructPointer[TypeObject], size: int
) -> StructPointer[VarObject]:
return api_binding_base(API_FUNCS["PyObject_InitVar"], op, type, size)
# PyObject_IsInstance
@staticmethod
def is_instance(inst: PyObjectLike, cls: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyObject_IsInstance"], _deref_maybe(inst), _deref_maybe(cls)
)
# PyObject_IsSubclass
@staticmethod
def is_subclass(derived: PyObjectLike, cls: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyObject_IsSubclass"], _deref_maybe(derived), _deref_maybe(cls)
)
# PyObject_IsTrue
@staticmethod
def is_true(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyObject_IsTrue"], _deref_maybe(o))
# PyObject_Length
@staticmethod
def length(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyObject_Length"], _deref_maybe(o))
# PyObject_Malloc
@staticmethod
def malloc(n: int) -> PointerLike:
return api_binding_base(API_FUNCS["PyObject_Malloc"], n)
# PyObject_Not
@staticmethod
def not_(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyObject_Not"], _deref_maybe(o))
# PyObject_Realloc
@staticmethod
def realloc(p: PointerLike, n: int) -> PointerLike:
return api_binding_base(API_FUNCS["PyObject_Realloc"], p, n)
# PyObject_Repr
@staticmethod
def repr(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyObject_Repr"], _deref_maybe(o))
# PyObject_RichCompare
@staticmethod
def rich_compare(o1: PyObjectLike, o2: PyObjectLike, opid: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyObject_RichCompare"], _deref_maybe(o1), _deref_maybe(o2), opid
)
# PyObject_RichCompareBool
@staticmethod
def rich_compare_bool(o1: PyObjectLike, o2: PyObjectLike, opid: int) -> int:
return api_binding_base(
API_FUNCS["PyObject_RichCompareBool"],
_deref_maybe(o1),
_deref_maybe(o2),
opid,
)
# PyObject_SetAttr
@staticmethod
def set_attr(o: PyObjectLike, attr_name: PyObjectLike, v: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyObject_SetAttr"],
_deref_maybe(o),
_deref_maybe(attr_name),
_deref_maybe(v),
)
# PyObject_SetAttrString
@staticmethod
def set_attr_string(o: PyObjectLike, attr_name: StringLike, v: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyObject_SetAttrString"],
_deref_maybe(o),
make_string(attr_name),
_deref_maybe(v),
)
# PyObject_SetItem
@staticmethod
def set_item(o: PyObjectLike, key: PyObjectLike, v: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyObject_SetItem"],
_deref_maybe(o),
_deref_maybe(key),
_deref_maybe(v),
)
# PyObject_Size
@staticmethod
def size(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyObject_Size"], _deref_maybe(o))
# PyObject_Str
@staticmethod
def str(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyObject_Str"], _deref_maybe(o))
# PyObject_Type
@staticmethod
def type(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyObject_Type"], _deref_maybe(o))
# PyObject_GET_WEAKREFS_LISTPTR
@staticmethod
def get_weakrefs_listptr(op: PyObjectLike) -> PointerLike:
return api_binding_base(
API_FUNCS["PyObject_GET_WEAKREFS_LISTPTR"], _deref_maybe(op)
)
class PySeqIter(_CallBase):
"""Namespace containing API functions prefixed with `PySeqIter_`"""
# PySeqIter_New
@staticmethod
def new(seq: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PySeqIter_New"], _deref_maybe(seq))
class PySequence(_CallBase):
"""Namespace containing API functions prefixed with `PySequence_`"""
# PySequence_Check
@staticmethod
def check(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PySequence_Check"], _deref_maybe(o))
# PySequence_Concat
@staticmethod
def concat(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PySequence_Concat"], _deref_maybe(o1), _deref_maybe(o2)
)
# PySequence_Contains
@staticmethod
def contains(o: PyObjectLike, value: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PySequence_Contains"], _deref_maybe(o), _deref_maybe(value)
)
# PySequence_Count
@staticmethod
def count(o: PyObjectLike, value: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PySequence_Count"], _deref_maybe(o), _deref_maybe(value)
)
# PySequence_DelItem
@staticmethod
def del_item(o: PyObjectLike, i: int) -> int:
return api_binding_base(API_FUNCS["PySequence_DelItem"], _deref_maybe(o), i)
# PySequence_DelSlice
@staticmethod
def del_slice(o: PyObjectLike, i1: int, i2: int) -> int:
return api_binding_base(
API_FUNCS["PySequence_DelSlice"], _deref_maybe(o), i1, i2
)
# PySequence_Fast
@staticmethod
def fast(o: PyObjectLike, m: StringLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PySequence_Fast"], _deref_maybe(o), make_string(m)
)
# PySequence_GetItem
@staticmethod
def get_item(o: PyObjectLike, i: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PySequence_GetItem"], _deref_maybe(o), i)
# PySequence_GetSlice
@staticmethod
def get_slice(o: PyObjectLike, i1: int, i2: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PySequence_GetSlice"], _deref_maybe(o), i1, i2
)
# PySequence_InPlaceConcat
@staticmethod
def in_place_concat(o1: PyObjectLike, o2: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PySequence_InPlaceConcat"], _deref_maybe(o1), _deref_maybe(o2)
)
# PySequence_InPlaceRepeat
@staticmethod
def in_place_repeat(o: PyObjectLike, count: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PySequence_InPlaceRepeat"], _deref_maybe(o), count
)
# PySequence_Index
@staticmethod
def index(o: PyObjectLike, value: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PySequence_Index"], _deref_maybe(o), _deref_maybe(value)
)
# PySequence_Length
@staticmethod
def length(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PySequence_Length"], _deref_maybe(o))
# PySequence_List
@staticmethod
def list(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PySequence_List"], _deref_maybe(o))
# PySequence_Repeat
@staticmethod
def repeat(o: PyObjectLike, count: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PySequence_Repeat"], _deref_maybe(o), count)
# PySequence_SetItem
@staticmethod
def set_item(o: PyObjectLike, i: int, v: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PySequence_SetItem"], _deref_maybe(o), i, _deref_maybe(v)
)
# PySequence_SetSlice
@staticmethod
def set_slice(o: PyObjectLike, i1: int, i2: int, v: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PySequence_SetSlice"], _deref_maybe(o), i1, i2, _deref_maybe(v)
)
# PySequence_Size
@staticmethod
def size(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PySequence_Size"], _deref_maybe(o))
# PySequence_Tuple
@staticmethod
def tuple(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PySequence_Tuple"], _deref_maybe(o))
class PySet(_CallBase):
"""Namespace containing API functions prefixed with `PySet_`"""
# PySet_Add
@staticmethod
def add(set: PyObjectLike, key: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PySet_Add"], _deref_maybe(set), _deref_maybe(key)
)
# PySet_Clear
@staticmethod
def clear(set: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PySet_Clear"], _deref_maybe(set))
# PySet_Contains
@staticmethod
def contains(anyset: PyObjectLike, key: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PySet_Contains"], _deref_maybe(anyset), _deref_maybe(key)
)
# PySet_Discard
@staticmethod
def discard(set: PyObjectLike, key: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PySet_Discard"], _deref_maybe(set), _deref_maybe(key)
)
# PySet_New
@staticmethod
def new(iterable: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PySet_New"], _deref_maybe(iterable))
# PySet_Pop
@staticmethod
def pop(set: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PySet_Pop"], _deref_maybe(set))
# PySet_Size
@staticmethod
def size(anyset: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PySet_Size"], _deref_maybe(anyset))
class PySlice(_CallBase):
"""Namespace containing API functions prefixed with `PySlice_`"""
# PySlice_AdjustIndices
@staticmethod
def adjust_indices(
length: int, start: PointerLike, stop: PointerLike, step: int
) -> int:
return api_binding_base(
API_FUNCS["PySlice_AdjustIndices"], length, start, stop, step
)
# PySlice_GetIndices
@staticmethod
def get_indices(
slice: PyObjectLike,
length: int,
start: PointerLike,
stop: PointerLike,
step: PointerLike,
) -> int:
return api_binding_base(
API_FUNCS["PySlice_GetIndices"],
_deref_maybe(slice),
length,
start,
stop,
step,
)
# PySlice_GetIndicesEx
@staticmethod
def get_indices_ex(
slice: PyObjectLike,
length: int,
start: PointerLike,
stop: PointerLike,
step: PointerLike,
slicelength: PointerLike,
) -> int:
return api_binding_base(
API_FUNCS["PySlice_GetIndicesEx"],
_deref_maybe(slice),
length,
start,
stop,
step,
slicelength,
)
# PySlice_New
@staticmethod
def new(
start: PyObjectLike, stop: PyObjectLike, step: PyObjectLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PySlice_New"],
_deref_maybe(start),
_deref_maybe(stop),
_deref_maybe(step),
)
# PySlice_Unpack
@staticmethod
def unpack(
slice: PyObjectLike, start: PointerLike, stop: PointerLike, step: PointerLike
) -> int:
return api_binding_base(
API_FUNCS["PySlice_Unpack"], _deref_maybe(slice), start, stop, step
)
class PyState(_CallBase):
"""Namespace containing API functions prefixed with `PyState_`"""
# PyState_AddModule
@staticmethod
def add_module(module: PyObjectLike, df: StructPointer[ModuleDef]) -> int:
return api_binding_base(
API_FUNCS["PyState_AddModule"], _deref_maybe(module), df
)
# PyState_FindModule
@staticmethod
def find_module(df: StructPointer[ModuleDef]) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyState_FindModule"], df)
# PyState_RemoveModule
@staticmethod
def remove_module(df: StructPointer[ModuleDef]) -> int:
return api_binding_base(API_FUNCS["PyState_RemoveModule"], df)
class PyStructSequence(_CallBase):
"""Namespace containing API functions prefixed with `PyStructSequence_`"""
# PyStructSequence_GetItem
@staticmethod
def get_item(p: PyObjectLike, pos: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyStructSequence_GetItem"], _deref_maybe(p), pos
)
# PyStructSequence_New
@staticmethod
def new(type: StructPointer[TypeObject]) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyStructSequence_New"], type)
# PyStructSequence_NewType
@staticmethod
def new_type() -> StructPointer[TypeObject]:
return api_binding_base(
API_FUNCS["PyStructSequence_NewType"],
)
# PyStructSequence_SetItem
@staticmethod
def set_item(p: PyObjectLike, pos: int, o: PyObjectLike) -> None:
return api_binding_base(
API_FUNCS["PyStructSequence_SetItem"], _deref_maybe(p), pos, _deref_maybe(o)
)
class PySys(_CallBase):
"""Namespace containing API functions prefixed with `PySys_`"""
# PySys_AddWarnOption
@staticmethod
def add_warn_option(s: str) -> None:
return api_binding_base(API_FUNCS["PySys_AddWarnOption"], s)
# PySys_AddWarnOptionUnicode
@staticmethod
def add_warn_option_unicode(unicode: PyObjectLike) -> None:
return api_binding_base(
API_FUNCS["PySys_AddWarnOptionUnicode"], _deref_maybe(unicode)
)
# PySys_AddXOption
@staticmethod
def add_x_option(s: str) -> None:
return api_binding_base(API_FUNCS["PySys_AddXOption"], s)
# PySys_GetObject
@staticmethod
def get_object(name: StringLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PySys_GetObject"], make_string(name))
# PySys_GetXOptions
@staticmethod
def get_x_options() -> PyObjectLike:
return api_binding_base(
API_FUNCS["PySys_GetXOptions"],
)
# PySys_ResetWarnOptions
@staticmethod
def reset_warn_options() -> None:
return api_binding_base(
API_FUNCS["PySys_ResetWarnOptions"],
)
# PySys_SetArgv
@staticmethod
def set_argv(argc: int, argv: PointerLike) -> None:
return api_binding_base(API_FUNCS["PySys_SetArgv"], argc, argv)
# PySys_SetArgvEx
@staticmethod
def set_argv_ex(argc: int, argv: PointerLike, updatepath: int) -> None:
return api_binding_base(API_FUNCS["PySys_SetArgvEx"], argc, argv, updatepath)
# PySys_SetObject
@staticmethod
def set_object(name: StringLike, v: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PySys_SetObject"], make_string(name), _deref_maybe(v)
)
# PySys_SetPath
@staticmethod
def set_path(path: str) -> None:
return api_binding_base(API_FUNCS["PySys_SetPath"], path)
class PyThreadState(_CallBase):
"""Namespace containing API functions prefixed with `PyThreadState_`"""
# PyThreadState_Clear
@staticmethod
def clear(tstate: StructPointer[ThreadState]) -> None:
return api_binding_base(API_FUNCS["PyThreadState_Clear"], tstate)
# PyThreadState_Delete
@staticmethod
def delete(tstate: StructPointer[ThreadState]) -> None:
return api_binding_base(API_FUNCS["PyThreadState_Delete"], tstate)
# PyThreadState_Get
@staticmethod
def get() -> StructPointer[ThreadState]:
return api_binding_base(
API_FUNCS["PyThreadState_Get"],
)
# PyThreadState_GetDict
@staticmethod
def get_dict() -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyThreadState_GetDict"],
)
# PyThreadState_GetFrame
@staticmethod
def get_frame(tstate: StructPointer[ThreadState]) -> StructPointer[FrameObject]:
return api_binding_base(API_FUNCS["PyThreadState_GetFrame"], tstate)
# PyThreadState_GetID
@staticmethod
def get_i_d(tstate: StructPointer[ThreadState]) -> int:
return api_binding_base(API_FUNCS["PyThreadState_GetID"], tstate)
# PyThreadState_GetInterpreter
@staticmethod
def get_interpreter(
tstate: StructPointer[ThreadState],
) -> StructPointer[InterpreterState]:
return api_binding_base(API_FUNCS["PyThreadState_GetInterpreter"], tstate)
# PyThreadState_New
@staticmethod
def new(interp: StructPointer[InterpreterState]) -> StructPointer[ThreadState]:
return api_binding_base(API_FUNCS["PyThreadState_New"], interp)
# PyThreadState_SetAsyncExc
@staticmethod
def set_async_exc(id: int, exc: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyThreadState_SetAsyncExc"], id, _deref_maybe(exc)
)
# PyThreadState_Swap
@staticmethod
def swap(tstate: StructPointer[ThreadState]) -> StructPointer[ThreadState]:
return api_binding_base(API_FUNCS["PyThreadState_Swap"], tstate)
class PyThread(_CallBase):
"""Namespace containing API functions prefixed with `PyThread_`"""
# PyThread_ReInitTLS
@staticmethod
def re_init_t_l_s() -> None:
return api_binding_base(
API_FUNCS["PyThread_ReInitTLS"],
)
# PyThread_create_key
@staticmethod
def create_key() -> int:
return api_binding_base(
API_FUNCS["PyThread_create_key"],
)
# PyThread_delete_key
@staticmethod
def delete_key(key: int) -> None:
return api_binding_base(API_FUNCS["PyThread_delete_key"], key)
# PyThread_delete_key_value
@staticmethod
def delete_key_value(key: int) -> None:
return api_binding_base(API_FUNCS["PyThread_delete_key_value"], key)
# PyThread_get_key_value
@staticmethod
def get_key_value(key: int) -> PointerLike:
return api_binding_base(API_FUNCS["PyThread_get_key_value"], key)
# PyThread_set_key_value
@staticmethod
def set_key_value(key: int, value: PointerLike) -> int:
return api_binding_base(API_FUNCS["PyThread_set_key_value"], key, value)
# PyThread_tss_alloc
@staticmethod
def tss_alloc() -> StructPointer[TssT]:
return api_binding_base(
API_FUNCS["PyThread_tss_alloc"],
)
# PyThread_tss_create
@staticmethod
def tss_create(key: StructPointer[TssT]) -> int:
return api_binding_base(API_FUNCS["PyThread_tss_create"], key)
# PyThread_tss_delete
@staticmethod
def tss_delete(key: StructPointer[TssT]) -> None:
return api_binding_base(API_FUNCS["PyThread_tss_delete"], key)
# PyThread_tss_free
@staticmethod
def tss_free(key: StructPointer[TssT]) -> None:
return api_binding_base(API_FUNCS["PyThread_tss_free"], key)
# PyThread_tss_get
@staticmethod
def tss_get(key: StructPointer[TssT]) -> PointerLike:
return api_binding_base(API_FUNCS["PyThread_tss_get"], key)
# PyThread_tss_is_created
@staticmethod
def tss_is_created(key: StructPointer[TssT]) -> int:
return api_binding_base(API_FUNCS["PyThread_tss_is_created"], key)
# PyThread_tss_set
@staticmethod
def tss_set(key: StructPointer[TssT], value: PointerLike) -> int:
return api_binding_base(API_FUNCS["PyThread_tss_set"], key, value)
class PyTuple(_CallBase):
"""Namespace containing API functions prefixed with `PyTuple_`"""
# PyTuple_GetItem
@staticmethod
def get_item(p: PyObjectLike, pos: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyTuple_GetItem"], _deref_maybe(p), pos)
# PyTuple_GetSlice
@staticmethod
def get_slice(p: PyObjectLike, low: int, high: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyTuple_GetSlice"], _deref_maybe(p), low, high
)
# PyTuple_New
@staticmethod
def new(len: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyTuple_New"], len)
# PyTuple_SetItem
@staticmethod
def set_item(p: PyObjectLike, pos: int, o: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyTuple_SetItem"], _deref_maybe(p), pos, _deref_maybe(o)
)
# PyTuple_Size
@staticmethod
def size(p: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyTuple_Size"], _deref_maybe(p))
class PyType(_CallBase):
"""Namespace containing API functions prefixed with `PyType_`"""
# PyType_ClearCache
@staticmethod
def clear_cache() -> int:
return api_binding_base(
API_FUNCS["PyType_ClearCache"],
)
# PyType_FromModuleAndSpec
@staticmethod
def from_module_and_spec(
module: PyObjectLike, spec: StructPointer[PyTypeSpec], bases: PyObjectLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyType_FromModuleAndSpec"],
_deref_maybe(module),
spec,
_deref_maybe(bases),
)
# PyType_FromSpec
@staticmethod
def from_spec(spec: StructPointer[PyTypeSpec]) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyType_FromSpec"], spec)
# PyType_FromSpecWithBases
@staticmethod
def from_spec_with_bases(
spec: StructPointer[PyTypeSpec], bases: PyObjectLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyType_FromSpecWithBases"], spec, _deref_maybe(bases)
)
# PyType_GenericAlloc
@staticmethod
def generic_alloc(type: StructPointer[TypeObject], nitems: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyType_GenericAlloc"], type, nitems)
# PyType_GenericNew
@staticmethod
def generic_new(
type: StructPointer[TypeObject], args: PyObjectLike, kwds: PyObjectLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyType_GenericNew"], type, _deref_maybe(args), _deref_maybe(kwds)
)
# PyType_GetFlags
@staticmethod
def get_flags(type: StructPointer[TypeObject]) -> int:
return api_binding_base(API_FUNCS["PyType_GetFlags"], type)
# PyType_GetModule
@staticmethod
def get_module(type: StructPointer[TypeObject]) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyType_GetModule"], type)
# PyType_GetModuleState
@staticmethod
def get_module_state(type: StructPointer[TypeObject]) -> PointerLike:
return api_binding_base(API_FUNCS["PyType_GetModuleState"], type)
# PyType_GetSlot
@staticmethod
def get_slot(type: StructPointer[TypeObject], slot: int) -> PointerLike:
return api_binding_base(API_FUNCS["PyType_GetSlot"], type, slot)
# PyType_IsSubtype
@staticmethod
def is_subtype(a: StructPointer[TypeObject], b: StructPointer[TypeObject]) -> int:
return api_binding_base(API_FUNCS["PyType_IsSubtype"], a, b)
# PyType_Modified
@staticmethod
def modified(type: StructPointer[TypeObject]) -> None:
return api_binding_base(API_FUNCS["PyType_Modified"], type)
# PyType_Ready
@staticmethod
def ready(type: StructPointer[TypeObject]) -> int:
return api_binding_base(API_FUNCS["PyType_Ready"], type)
class PyUnicodeDecodeError(_CallBase):
"""Namespace containing API functions prefixed with `PyUnicodeDecodeError_`"""
# PyUnicodeDecodeError_Create
@staticmethod
def create(
encoding: StringLike,
object: StringLike,
length: int,
start: int,
end: int,
reason: StringLike,
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicodeDecodeError_Create"],
make_string(encoding),
make_string(object),
length,
start,
end,
make_string(reason),
)
# PyUnicodeDecodeError_GetEncoding
@staticmethod
def get_encoding(exc: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicodeDecodeError_GetEncoding"], _deref_maybe(exc)
)
# PyUnicodeDecodeError_GetEnd
@staticmethod
def get_end(exc: PyObjectLike, end: PointerLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeDecodeError_GetEnd"], _deref_maybe(exc), end
)
# PyUnicodeDecodeError_GetObject
@staticmethod
def get_object(exc: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicodeDecodeError_GetObject"], _deref_maybe(exc)
)
# PyUnicodeDecodeError_GetReason
@staticmethod
def get_reason(exc: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicodeDecodeError_GetReason"], _deref_maybe(exc)
)
# PyUnicodeDecodeError_GetStart
@staticmethod
def get_start(exc: PyObjectLike, start: PointerLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeDecodeError_GetStart"], _deref_maybe(exc), start
)
# PyUnicodeDecodeError_SetEnd
@staticmethod
def set_end(exc: PyObjectLike, end: int) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeDecodeError_SetEnd"], _deref_maybe(exc), end
)
# PyUnicodeDecodeError_SetReason
@staticmethod
def set_reason(exc: PyObjectLike, reason: StringLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeDecodeError_SetReason"],
_deref_maybe(exc),
make_string(reason),
)
# PyUnicodeDecodeError_SetStart
@staticmethod
def set_start(exc: PyObjectLike, start: int) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeDecodeError_SetStart"], _deref_maybe(exc), start
)
class PyUnicodeEncodeError(_CallBase):
"""Namespace containing API functions prefixed with `PyUnicodeEncodeError_`"""
# PyUnicodeEncodeError_GetEncoding
@staticmethod
def get_encoding(exc: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicodeEncodeError_GetEncoding"], _deref_maybe(exc)
)
# PyUnicodeEncodeError_GetEnd
@staticmethod
def get_end(exc: PyObjectLike, end: PointerLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeEncodeError_GetEnd"], _deref_maybe(exc), end
)
# PyUnicodeEncodeError_GetObject
@staticmethod
def get_object(exc: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicodeEncodeError_GetObject"], _deref_maybe(exc)
)
# PyUnicodeEncodeError_GetReason
@staticmethod
def get_reason(exc: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicodeEncodeError_GetReason"], _deref_maybe(exc)
)
# PyUnicodeEncodeError_GetStart
@staticmethod
def get_start(exc: PyObjectLike, start: PointerLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeEncodeError_GetStart"], _deref_maybe(exc), start
)
# PyUnicodeEncodeError_SetEnd
@staticmethod
def set_end(exc: PyObjectLike, end: int) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeEncodeError_SetEnd"], _deref_maybe(exc), end
)
# PyUnicodeEncodeError_SetReason
@staticmethod
def set_reason(exc: PyObjectLike, reason: StringLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeEncodeError_SetReason"],
_deref_maybe(exc),
make_string(reason),
)
# PyUnicodeEncodeError_SetStart
@staticmethod
def set_start(exc: PyObjectLike, start: int) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeEncodeError_SetStart"], _deref_maybe(exc), start
)
class PyUnicodeTranslateError(_CallBase):
"""Namespace containing API functions prefixed with `PyUnicodeTranslateError_`"""
# PyUnicodeTranslateError_GetEnd
@staticmethod
def get_end(exc: PyObjectLike, end: PointerLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeTranslateError_GetEnd"], _deref_maybe(exc), end
)
# PyUnicodeTranslateError_GetObject
@staticmethod
def get_object(exc: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicodeTranslateError_GetObject"], _deref_maybe(exc)
)
# PyUnicodeTranslateError_GetReason
@staticmethod
def get_reason(exc: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicodeTranslateError_GetReason"], _deref_maybe(exc)
)
# PyUnicodeTranslateError_GetStart
@staticmethod
def get_start(exc: PyObjectLike, start: PointerLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeTranslateError_GetStart"], _deref_maybe(exc), start
)
# PyUnicodeTranslateError_SetEnd
@staticmethod
def set_end(exc: PyObjectLike, end: int) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeTranslateError_SetEnd"], _deref_maybe(exc), end
)
# PyUnicodeTranslateError_SetReason
@staticmethod
def set_reason(exc: PyObjectLike, reason: StringLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeTranslateError_SetReason"],
_deref_maybe(exc),
make_string(reason),
)
# PyUnicodeTranslateError_SetStart
@staticmethod
def set_start(exc: PyObjectLike, start: int) -> int:
return api_binding_base(
API_FUNCS["PyUnicodeTranslateError_SetStart"], _deref_maybe(exc), start
)
class PyUnicode(_CallBase):
"""Namespace containing API functions prefixed with `PyUnicode_`"""
# PyUnicode_AsASCIIString
@staticmethod
def as_ascii_string(unicode: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_AsASCIIString"], _deref_maybe(unicode)
)
# PyUnicode_AsCharmapString
@staticmethod
def as_charmap_string(unicode: PyObjectLike, mapping: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_AsCharmapString"],
_deref_maybe(unicode),
_deref_maybe(mapping),
)
# PyUnicode_AsEncodedString
@staticmethod
def as_encoded_string(
unicode: PyObjectLike, encoding: StringLike, errors: StringLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_AsEncodedString"],
_deref_maybe(unicode),
make_string(encoding),
make_string(errors),
)
# PyUnicode_AsLatin1String
@staticmethod
def as_latin1_string(unicode: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_AsLatin1String"], _deref_maybe(unicode)
)
# PyUnicode_AsRawUnicodeEscapeString
@staticmethod
def as_raw_unicode_escape_string(unicode: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_AsRawUnicodeEscapeString"], _deref_maybe(unicode)
)
# PyUnicode_AsUCS4
@staticmethod
def as_ucs_4(
u: PyObjectLike, buffer: PointerLike, buflen: int, copy_null: int
) -> PointerLike:
return api_binding_base(
API_FUNCS["PyUnicode_AsUCS4"], _deref_maybe(u), buffer, buflen, copy_null
)
# PyUnicode_AsUCS4Copy
@staticmethod
def as_ucs_4_copy(u: PyObjectLike) -> PointerLike:
return api_binding_base(API_FUNCS["PyUnicode_AsUCS4Copy"], _deref_maybe(u))
# PyUnicode_AsUTF16String
@staticmethod
def as_utf_16_string(unicode: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_AsUTF16String"], _deref_maybe(unicode)
)
# PyUnicode_AsUTF32String
@staticmethod
def as_utf_32_string(unicode: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_AsUTF32String"], _deref_maybe(unicode)
)
# PyUnicode_AsUTF8AndSize
@staticmethod
def as_utf_8_and_size(unicode: PyObjectLike, size: PointerLike) -> StringLike:
return api_binding_base(
API_FUNCS["PyUnicode_AsUTF8AndSize"], _deref_maybe(unicode), size
)
# PyUnicode_AsUTF8String
@staticmethod
def as_utf_8_string(unicode: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_AsUTF8String"], _deref_maybe(unicode)
)
# PyUnicode_AsUnicodeEscapeString
@staticmethod
def as_unicode_escape_string(unicode: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_AsUnicodeEscapeString"], _deref_maybe(unicode)
)
# PyUnicode_AsWideChar
@staticmethod
def as_wide_char(unicode: PyObjectLike, w: str, size: int) -> int:
return api_binding_base(
API_FUNCS["PyUnicode_AsWideChar"], _deref_maybe(unicode), w, size
)
# PyUnicode_AsWideCharString
@staticmethod
def as_wide_char_string(unicode: PyObjectLike, size: PointerLike) -> str:
return api_binding_base(
API_FUNCS["PyUnicode_AsWideCharString"], _deref_maybe(unicode), size
)
# PyUnicode_Compare
@staticmethod
def compare(left: PyObjectLike, right: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicode_Compare"], _deref_maybe(left), _deref_maybe(right)
)
# PyUnicode_CompareWithASCIIString
@staticmethod
def compare_with_ascii_string(uni: PyObjectLike, string: StringLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicode_CompareWithASCIIString"],
_deref_maybe(uni),
make_string(string),
)
# PyUnicode_Concat
@staticmethod
def concat(left: PyObjectLike, right: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_Concat"], _deref_maybe(left), _deref_maybe(right)
)
# PyUnicode_Contains
@staticmethod
def contains(container: PyObjectLike, element: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicode_Contains"],
_deref_maybe(container),
_deref_maybe(element),
)
# PyUnicode_Count
@staticmethod
def count(str: PyObjectLike, substr: PyObjectLike, start: int, end: int) -> int:
return api_binding_base(
API_FUNCS["PyUnicode_Count"],
_deref_maybe(str),
_deref_maybe(substr),
start,
end,
)
# PyUnicode_Decode
@staticmethod
def decode(
s: StringLike, size: int, encoding: StringLike, errors: StringLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_Decode"],
make_string(s),
size,
make_string(encoding),
make_string(errors),
)
# PyUnicode_DecodeASCII
@staticmethod
def decode_ascii(s: StringLike, size: int, errors: StringLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeASCII"],
make_string(s),
size,
make_string(errors),
)
# PyUnicode_DecodeCharmap
@staticmethod
def decode_charmap(
data: StringLike, size: int, mapping: PyObjectLike, errors: StringLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeCharmap"],
make_string(data),
size,
_deref_maybe(mapping),
make_string(errors),
)
# PyUnicode_DecodeFSDefault
@staticmethod
def decode_fsdefault(s: StringLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyUnicode_DecodeFSDefault"], make_string(s))
# PyUnicode_DecodeFSDefaultAndSize
@staticmethod
def decode_fs_default_and_size(s: StringLike, size: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeFSDefaultAndSize"], make_string(s), size
)
# PyUnicode_DecodeLatin1
@staticmethod
def decode_latin1(s: StringLike, size: int, errors: StringLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeLatin1"],
make_string(s),
size,
make_string(errors),
)
# PyUnicode_DecodeLocale
@staticmethod
def decode_locale(str: StringLike, errors: StringLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeLocale"], make_string(str), make_string(errors)
)
# PyUnicode_DecodeLocaleAndSize
@staticmethod
def decode_locale_and_size(
str: StringLike, len: int, errors: StringLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeLocaleAndSize"],
make_string(str),
len,
make_string(errors),
)
# PyUnicode_DecodeRawUnicodeEscape
@staticmethod
def decode_raw_unicode_escape(
s: StringLike, size: int, errors: StringLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeRawUnicodeEscape"],
make_string(s),
size,
make_string(errors),
)
# PyUnicode_DecodeUTF16
@staticmethod
def decode_utf_16(
s: StringLike, size: int, errors: StringLike, byteorder: PointerLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeUTF16"],
make_string(s),
size,
make_string(errors),
byteorder,
)
# PyUnicode_DecodeUTF16Stateful
@staticmethod
def decode_utf_16_stateful(
s: StringLike,
size: int,
errors: StringLike,
byteorder: PointerLike,
consumed: PointerLike,
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeUTF16Stateful"],
make_string(s),
size,
make_string(errors),
byteorder,
consumed,
)
# PyUnicode_DecodeUTF32
@staticmethod
def decode_utf_32(
s: StringLike, size: int, errors: StringLike, byteorder: PointerLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeUTF32"],
make_string(s),
size,
make_string(errors),
byteorder,
)
# PyUnicode_DecodeUTF32Stateful
@staticmethod
def decode_utf_32_stateful(
s: StringLike,
size: int,
errors: StringLike,
byteorder: PointerLike,
consumed: PointerLike,
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeUTF32Stateful"],
make_string(s),
size,
make_string(errors),
byteorder,
consumed,
)
# PyUnicode_DecodeUTF7
@staticmethod
def decode_utf_7(s: StringLike, size: int, errors: StringLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeUTF7"], make_string(s), size, make_string(errors)
)
# PyUnicode_DecodeUTF7Stateful
@staticmethod
def decode_utf_7_stateful(
s: StringLike, size: int, errors: StringLike, consumed: PointerLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeUTF7Stateful"],
make_string(s),
size,
make_string(errors),
consumed,
)
# PyUnicode_DecodeUTF8
@staticmethod
def decode_utf_8(s: StringLike, size: int, errors: StringLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeUTF8"], make_string(s), size, make_string(errors)
)
# PyUnicode_DecodeUTF8Stateful
@staticmethod
def decode_utf_8_stateful(
s: StringLike, size: int, errors: StringLike, consumed: PointerLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeUTF8Stateful"],
make_string(s),
size,
make_string(errors),
consumed,
)
# PyUnicode_DecodeUnicodeEscape
@staticmethod
def decode_unicode_escape(
s: StringLike, size: int, errors: StringLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_DecodeUnicodeEscape"],
make_string(s),
size,
make_string(errors),
)
# PyUnicode_EncodeFSDefault
@staticmethod
def encode_fs_default(unicode: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_EncodeFSDefault"], _deref_maybe(unicode)
)
# PyUnicode_EncodeLocale
@staticmethod
def encode_locale(unicode: PyObjectLike, errors: StringLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_EncodeLocale"],
_deref_maybe(unicode),
make_string(errors),
)
# PyUnicode_FSConverter
@staticmethod
def fs_converter(obj: PyObjectLike, result: PointerLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicode_FSConverter"], _deref_maybe(obj), result
)
# PyUnicode_FSDecoder
@staticmethod
def fs_decoder(obj: PyObjectLike, result: PointerLike) -> int:
return api_binding_base(
API_FUNCS["PyUnicode_FSDecoder"], _deref_maybe(obj), result
)
# PyUnicode_Find
@staticmethod
def find(
str: PyObjectLike, substr: PyObjectLike, start: int, end: int, direction: int
) -> int:
return api_binding_base(
API_FUNCS["PyUnicode_Find"],
_deref_maybe(str),
_deref_maybe(substr),
start,
end,
direction,
)
# PyUnicode_FindChar
@staticmethod
def find_char(
str: PyObjectLike, ch: int, start: int, end: int, direction: int
) -> int:
return api_binding_base(
API_FUNCS["PyUnicode_FindChar"],
_deref_maybe(str),
ch,
start,
end,
direction,
)
# PyUnicode_Format
@staticmethod
def format(format: PyObjectLike, args: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_Format"], _deref_maybe(format), _deref_maybe(args)
)
# PyUnicode_FromEncodedObject
@staticmethod
def from_encoded_object(
obj: PyObjectLike, encoding: StringLike, errors: StringLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_FromEncodedObject"],
_deref_maybe(obj),
make_string(encoding),
make_string(errors),
)
# PyUnicode_FromFormatV
@staticmethod
def from_format_v(format: StringLike, vargs: PointerLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_FromFormatV"], make_string(format), vargs
)
# PyUnicode_FromObject
@staticmethod
def from_object(obj: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyUnicode_FromObject"], _deref_maybe(obj))
# PyUnicode_FromString
@staticmethod
def from_string(u: StringLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyUnicode_FromString"], make_string(u))
# PyUnicode_FromStringAndSize
@staticmethod
def from_string_and_size(u: StringLike, size: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_FromStringAndSize"], make_string(u), size
)
# PyUnicode_FromWideChar
@staticmethod
def from_wide_char(w: str, size: int) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyUnicode_FromWideChar"], w, size)
# PyUnicode_GetLength
@staticmethod
def get_length(unicode: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyUnicode_GetLength"], _deref_maybe(unicode))
# PyUnicode_GetSize
@staticmethod
def get_size(unicode: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyUnicode_GetSize"], _deref_maybe(unicode))
# PyUnicode_InternFromString
@staticmethod
def intern_from_string(v: StringLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyUnicode_InternFromString"], make_string(v))
# PyUnicode_InternInPlace
@staticmethod
def intern_in_place(string: PointerLike) -> None:
return api_binding_base(API_FUNCS["PyUnicode_InternInPlace"], string)
# PyUnicode_IsIdentifier
@staticmethod
def is_identifier(o: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["PyUnicode_IsIdentifier"], _deref_maybe(o))
# PyUnicode_Join
@staticmethod
def join(separator: PyObjectLike, seq: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_Join"], _deref_maybe(separator), _deref_maybe(seq)
)
# PyUnicode_ReadChar
@staticmethod
def read_char(unicode: PyObjectLike, index: int) -> int:
return api_binding_base(
API_FUNCS["PyUnicode_ReadChar"], _deref_maybe(unicode), index
)
# PyUnicode_Replace
@staticmethod
def replace(
str: PyObjectLike, substr: PyObjectLike, replstr: PyObjectLike, maxcount: int
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_Replace"],
_deref_maybe(str),
_deref_maybe(substr),
_deref_maybe(replstr),
maxcount,
)
# PyUnicode_RichCompare
@staticmethod
def rich_compare(left: PyObjectLike, right: PyObjectLike, op: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_RichCompare"],
_deref_maybe(left),
_deref_maybe(right),
op,
)
# PyUnicode_Split
@staticmethod
def split(s: PyObjectLike, sep: PyObjectLike, maxsplit: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_Split"], _deref_maybe(s), _deref_maybe(sep), maxsplit
)
# PyUnicode_Splitlines
@staticmethod
def splitlines(s: PyObjectLike, keepend: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_Splitlines"], _deref_maybe(s), keepend
)
# PyUnicode_Substring
@staticmethod
def substring(str: PyObjectLike, start: int, end: int) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_Substring"], _deref_maybe(str), start, end
)
# PyUnicode_Tailmatch
@staticmethod
def tailmatch(
str: PyObjectLike, substr: PyObjectLike, start: int, end: int, direction: int
) -> int:
return api_binding_base(
API_FUNCS["PyUnicode_Tailmatch"],
_deref_maybe(str),
_deref_maybe(substr),
start,
end,
direction,
)
# PyUnicode_Translate
@staticmethod
def translate(
str: PyObjectLike, table: PyObjectLike, errors: StringLike
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyUnicode_Translate"],
_deref_maybe(str),
_deref_maybe(table),
make_string(errors),
)
# PyUnicode_WriteChar
@staticmethod
def write_char(unicode: PyObjectLike, index: int, character: int) -> int:
return api_binding_base(
API_FUNCS["PyUnicode_WriteChar"], _deref_maybe(unicode), index, character
)
class PyWeakref(_CallBase):
"""Namespace containing API functions prefixed with `PyWeakref_`"""
# PyWeakref_GetObject
@staticmethod
def get_object(ref: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["PyWeakref_GetObject"], _deref_maybe(ref))
# PyWeakref_NewProxy
@staticmethod
def new_proxy(ob: PyObjectLike, callback: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyWeakref_NewProxy"], _deref_maybe(ob), _deref_maybe(callback)
)
# PyWeakref_NewRef
@staticmethod
def new_ref(ob: PyObjectLike, callback: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyWeakref_NewRef"], _deref_maybe(ob), _deref_maybe(callback)
)
class Py(_CallBase):
"""Namespace containing API functions prefixed with `Py_`"""
# Py_AddPendingCall
@staticmethod
def add_pending_call(func: Callable[[PointerLike], int], arg: PointerLike) -> int:
return api_binding_base(API_FUNCS["Py_AddPendingCall"], func, arg)
# Py_BytesMain
@staticmethod
def bytes_main(argc: int, argv: PointerLike) -> int:
return api_binding_base(API_FUNCS["Py_BytesMain"], argc, argv)
# Py_CompileString
@staticmethod
def compile_string(
str: StringLike, filename: StringLike, start: int
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["Py_CompileString"],
make_string(str),
make_string(filename),
start,
)
# Py_DecRef
@staticmethod
def dec_ref(o: PyObjectLike) -> None:
return api_binding_base(API_FUNCS["Py_DecRef"], _deref_maybe(o))
# Py_DecodeLocale
@staticmethod
def decode_locale(arg: StringLike, size: PointerLike) -> str:
return api_binding_base(API_FUNCS["Py_DecodeLocale"], make_string(arg), size)
# Py_EncodeLocale
@staticmethod
def encode_locale(text: str, error_pos: PointerLike) -> StringLike:
return api_binding_base(API_FUNCS["Py_EncodeLocale"], text, error_pos)
# Py_EndInterpreter
@staticmethod
def end_interpreter(tstate: StructPointer[ThreadState]) -> None:
return api_binding_base(API_FUNCS["Py_EndInterpreter"], tstate)
# Py_EnterRecursiveCall
@staticmethod
def enter_recursive_call(where: StringLike) -> int:
return api_binding_base(API_FUNCS["Py_EnterRecursiveCall"], make_string(where))
# Py_Exit
@staticmethod
def exit(status: int) -> None:
return api_binding_base(API_FUNCS["Py_Exit"], status)
# Py_FatalError
@staticmethod
def fatal_error(message: StringLike) -> None:
return api_binding_base(API_FUNCS["Py_FatalError"], make_string(message))
# Py_Finalize
@staticmethod
def finalize() -> None:
return api_binding_base(
API_FUNCS["Py_Finalize"],
)
# Py_FinalizeEx
@staticmethod
def finalize_ex() -> int:
return api_binding_base(
API_FUNCS["Py_FinalizeEx"],
)
# Py_GenericAlias
@staticmethod
def generic_alias(origin: PyObjectLike, args: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["Py_GenericAlias"], _deref_maybe(origin), _deref_maybe(args)
)
# Py_GetBuildInfo
@staticmethod
def get_build_info() -> StringLike:
return api_binding_base(
API_FUNCS["Py_GetBuildInfo"],
)
# Py_GetCompiler
@staticmethod
def get_compiler() -> StringLike:
return api_binding_base(
API_FUNCS["Py_GetCompiler"],
)
# Py_GetCopyright
@staticmethod
def get_copyright() -> StringLike:
return api_binding_base(
API_FUNCS["Py_GetCopyright"],
)
# Py_GetExecPrefix
@staticmethod
def get_exec_prefix() -> str:
return api_binding_base(
API_FUNCS["Py_GetExecPrefix"],
)
# Py_GetPath
@staticmethod
def get_path() -> str:
return api_binding_base(
API_FUNCS["Py_GetPath"],
)
# Py_GetPlatform
@staticmethod
def get_platform() -> StringLike:
return api_binding_base(
API_FUNCS["Py_GetPlatform"],
)
# Py_GetPrefix
@staticmethod
def get_prefix() -> str:
return api_binding_base(
API_FUNCS["Py_GetPrefix"],
)
# Py_GetProgramFullPath
@staticmethod
def get_program_full_path() -> str:
return api_binding_base(
API_FUNCS["Py_GetProgramFullPath"],
)
# Py_GetProgramName
@staticmethod
def get_program_name() -> str:
return api_binding_base(
API_FUNCS["Py_GetProgramName"],
)
# Py_GetPythonHome
@staticmethod
def get_python_home() -> str:
return api_binding_base(
API_FUNCS["Py_GetPythonHome"],
)
# Py_GetVersion
@staticmethod
def get_version() -> StringLike:
return api_binding_base(
API_FUNCS["Py_GetVersion"],
)
# Py_IncRef
@staticmethod
def inc_ref(o: PyObjectLike) -> None:
return api_binding_base(API_FUNCS["Py_IncRef"], _deref_maybe(o))
# Py_Initialize
@staticmethod
def initialize() -> None:
return api_binding_base(
API_FUNCS["Py_Initialize"],
)
# Py_InitializeEx
@staticmethod
def initialize_ex(initsigs: int) -> None:
return api_binding_base(API_FUNCS["Py_InitializeEx"], initsigs)
# Py_Is
@staticmethod
def is_(x: PyObjectLike, y: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["Py_Is"], _deref_maybe(x), _deref_maybe(y))
# Py_IsFalse
@staticmethod
def is_false(x: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["Py_IsFalse"], _deref_maybe(x))
# Py_IsInitialized
@staticmethod
def is_initialized() -> int:
return api_binding_base(
API_FUNCS["Py_IsInitialized"],
)
# Py_IsNone
@staticmethod
def is_none(x: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["Py_IsNone"], _deref_maybe(x))
# Py_IsTrue
@staticmethod
def is_true(x: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["Py_IsTrue"], _deref_maybe(x))
# Py_LeaveRecursiveCall
@staticmethod
def leave_recursive_call() -> None:
return api_binding_base(
API_FUNCS["Py_LeaveRecursiveCall"],
)
# Py_Main
@staticmethod
def main(argc: int, argv: PointerLike) -> int:
return api_binding_base(API_FUNCS["Py_Main"], argc, argv)
# Py_NewInterpreter
@staticmethod
def new_interpreter() -> StructPointer[ThreadState]:
return api_binding_base(
API_FUNCS["Py_NewInterpreter"],
)
# Py_NewRef
@staticmethod
def new_ref(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["Py_NewRef"], _deref_maybe(o))
# Py_ReprEnter
@staticmethod
def repr_enter(object: PyObjectLike) -> int:
return api_binding_base(API_FUNCS["Py_ReprEnter"], _deref_maybe(object))
# Py_ReprLeave
@staticmethod
def repr_leave(object: PyObjectLike) -> None:
return api_binding_base(API_FUNCS["Py_ReprLeave"], _deref_maybe(object))
# Py_SetProgramName
@staticmethod
def set_program_name(name: str) -> None:
return api_binding_base(API_FUNCS["Py_SetProgramName"], name)
# Py_SetPythonHome
@staticmethod
def set_python_home(home: str) -> None:
return api_binding_base(API_FUNCS["Py_SetPythonHome"], home)
# Py_VaBuildValue
@staticmethod
def va_build_value(format: StringLike, vargs: PointerLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["Py_VaBuildValue"], make_string(format), vargs
)
# Py_XNewRef
@staticmethod
def x_new_ref(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["Py_XNewRef"], _deref_maybe(o))
class PyContext(_CallBase):
"""Namespace containing API functions prefixed with `PyContext_`"""
# PyContext_New
@staticmethod
def new() -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyContext_New"],
)
# PyContext_CopyCurrent
@staticmethod
def copy_current() -> PyObjectLike:
return api_binding_base(
API_FUNCS["PyContext_CopyCurrent"],
)
class _PyWarnings(_CallBase):
"""Namespace containing API functions prefixed with `_PyWarnings_`"""
# _PyWarnings_Init
@staticmethod
def init() -> PyObjectLike:
return api_binding_base(
API_FUNCS["_PyWarnings_Init"],
)
class _PyFrame(_CallBase):
"""Namespace containing API functions prefixed with `_PyFrame_`"""
# _PyFrame_DebugMallocStats
@staticmethod
def debug_malloc_stats(out: PointerLike) -> None:
return api_binding_base(API_FUNCS["_PyFrame_DebugMallocStats"], out)
class _Py(_CallBase):
"""Namespace containing API functions prefixed with `_Py_`"""
# _Py_NewReference
@staticmethod
def new_reference(op: PyObjectLike) -> None:
return api_binding_base(API_FUNCS["_Py_NewReference"], _deref_maybe(op))
# _Py_CoerceLegacyLocale
@staticmethod
def coerce_legacy_locale(warn: int) -> int:
return api_binding_base(API_FUNCS["_Py_CoerceLegacyLocale"], warn)
# _Py_LegacyLocaleDetected
@staticmethod
def legacy_locale_detected(warn: int) -> int:
return api_binding_base(API_FUNCS["_Py_LegacyLocaleDetected"], warn)
# _Py_SetLocaleFromEnv
@staticmethod
def set_locale_from_env(category: int) -> StringLike:
return api_binding_base(API_FUNCS["_Py_SetLocaleFromEnv"], category)
# _Py_NewInterpreter
@staticmethod
def new_interpreter(isolated_subinterpreter: int) -> StructPointer[ThreadState]:
return api_binding_base(
API_FUNCS["_Py_NewInterpreter"], isolated_subinterpreter
)
# _Py_DisplaySourceLine
@staticmethod
def display_source_line(
ob1: PyObjectLike, ob2: PyObjectLike, i1: int, i2: int
) -> int:
return api_binding_base(
API_FUNCS["_Py_DisplaySourceLine"],
_deref_maybe(ob1),
_deref_maybe(ob2),
i1,
i2,
)
# _Py_DecodeLocaleEx
@staticmethod
def decode_locale_ex(
arg: StringLike,
wstr: PointerLike,
wlen: PointerLike,
reason: PointerLike,
current_locale: int,
) -> int:
return api_binding_base(
API_FUNCS["_Py_DecodeLocaleEx"],
make_string(arg),
wstr,
wlen,
reason,
current_locale,
)
# _Py_EncodeLocaleEx
@staticmethod
def encode_locale_ex(
text: str,
str: PointerLike,
error_pos: PointerLike,
reason: PointerLike,
current_locale: int,
) -> int:
return api_binding_base(
API_FUNCS["_Py_EncodeLocaleEx"],
text,
str,
error_pos,
reason,
current_locale,
)
# _Py_EncodeLocaleRaw
@staticmethod
def encode_locale_raw(text: str, error_pos: PointerLike) -> StringLike:
return api_binding_base(API_FUNCS["_Py_EncodeLocaleRaw"], text, error_pos)
# _Py_DumpExtensionModules
@staticmethod
def dump_extension_modules(
fd: int, interp: StructPointer[InterpreterState]
) -> None:
return api_binding_base(API_FUNCS["_Py_DumpExtensionModules"], fd, interp)
# _Py_UTF8_Edit_Cost
@staticmethod
def utf_8_edit_cost(
str_a: PyObjectLike, str_b: PyObjectLike, max_cost: int
) -> int:
return api_binding_base(
API_FUNCS["_Py_UTF8_Edit_Cost"],
_deref_maybe(str_a),
_deref_maybe(str_b),
max_cost,
)
class PyCompile(_CallBase):
"""Namespace containing API functions prefixed with `PyCompile_`"""
# PyCompile_OpcodeStackEffect
@staticmethod
def opcode_stack_effect(opcode: int, oparg: int) -> int:
return api_binding_base(API_FUNCS["PyCompile_OpcodeStackEffect"], opcode, oparg)
# PyCompile_OpcodeStackEffectWithJump
@staticmethod
def opcode_stack_effect_with_jump(opcode: int, oparg: int, jump: int) -> int:
return api_binding_base(
API_FUNCS["PyCompile_OpcodeStackEffectWithJump"], opcode, oparg, jump
)
class _PyTraceback(_CallBase):
"""Namespace containing API functions prefixed with `_PyTraceback_`"""
# _PyTraceback_Add
@staticmethod
def add(a: StringLike, b: StringLike, i: int) -> None:
return api_binding_base(
API_FUNCS["_PyTraceback_Add"], make_string(a), make_string(b), i
)
class _PyImport(_CallBase):
"""Namespace containing API functions prefixed with `_PyImport_`"""
# _PyImport_GetModuleId
@staticmethod
def get_module_id() -> PyObjectLike:
return api_binding_base(
API_FUNCS["_PyImport_GetModuleId"],
)
# _PyImport_SetModule
@staticmethod
def set_module(name: PyObjectLike, module: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["_PyImport_SetModule"], _deref_maybe(name), _deref_maybe(module)
)
# _PyImport_SetModuleString
@staticmethod
def set_module_string(name: StringLike, module: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["_PyImport_SetModuleString"],
make_string(name),
_deref_maybe(module),
)
# _PyImport_AcquireLock
@staticmethod
def acquire_lock() -> None:
return api_binding_base(
API_FUNCS["_PyImport_AcquireLock"],
)
# _PyImport_ReleaseLock
@staticmethod
def release_lock() -> int:
return api_binding_base(
API_FUNCS["_PyImport_ReleaseLock"],
)
class _PyErr(_CallBase):
"""Namespace containing API functions prefixed with `_PyErr_`"""
# _PyErr_WriteUnraisableMsg
@staticmethod
def write_unraisable_msg(err_msg: StringLike, obj: PyObjectLike) -> None:
return api_binding_base(
API_FUNCS["_PyErr_WriteUnraisableMsg"],
make_string(err_msg),
_deref_maybe(obj),
)
# _PyErr_Fetch
@staticmethod
def fetch(
tstate: StructPointer[ThreadState],
type: PointerLike,
value: PointerLike,
traceback: PointerLike,
) -> None:
return api_binding_base(
API_FUNCS["_PyErr_Fetch"], tstate, type, value, traceback
)
# _PyErr_ExceptionMatches
@staticmethod
def exception_matches(tstate: StructPointer[ThreadState], exc: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["_PyErr_ExceptionMatches"], tstate, _deref_maybe(exc)
)
# _PyErr_Restore
@staticmethod
def restore(
tstate: StructPointer[ThreadState],
type: PyObjectLike,
value: PyObjectLike,
traceback: PyObjectLike,
) -> None:
return api_binding_base(
API_FUNCS["_PyErr_Restore"],
tstate,
_deref_maybe(type),
_deref_maybe(value),
_deref_maybe(traceback),
)
# _PyErr_SetObject
@staticmethod
def set_object(
tstate: StructPointer[ThreadState], type: PyObjectLike, value: PyObjectLike
) -> None:
return api_binding_base(
API_FUNCS["_PyErr_SetObject"],
tstate,
_deref_maybe(type),
_deref_maybe(value),
)
# _PyErr_ChainStackItem
@staticmethod
def chain_stack_item() -> None:
return api_binding_base(
API_FUNCS["_PyErr_ChainStackItem"],
)
# _PyErr_Clear
@staticmethod
def clear(tstate: StructPointer[ThreadState]) -> None:
return api_binding_base(API_FUNCS["_PyErr_Clear"], tstate)
# _PyErr_SetNone
@staticmethod
def set_none(tstate: StructPointer[ThreadState], exception: PyObjectLike) -> None:
return api_binding_base(
API_FUNCS["_PyErr_SetNone"], tstate, _deref_maybe(exception)
)
# _PyErr_NoMemory
@staticmethod
def no_memory(tstate: StructPointer[ThreadState]) -> PyObjectLike:
return api_binding_base(API_FUNCS["_PyErr_NoMemory"], tstate)
# _PyErr_SetString
@staticmethod
def set_string(
tstate: StructPointer[ThreadState], exception: PyObjectLike, string: StringLike
) -> None:
return api_binding_base(
API_FUNCS["_PyErr_SetString"],
tstate,
_deref_maybe(exception),
make_string(string),
)
# _PyErr_NormalizeException
@staticmethod
def normalize_exception(
tstate: StructPointer[ThreadState],
exc: PointerLike,
val: PointerLike,
tb: PointerLike,
) -> None:
return api_binding_base(
API_FUNCS["_PyErr_NormalizeException"], tstate, exc, val, tb
)
# _PyErr_CheckSignalsTstate
@staticmethod
def check_signals_tstate(tstate: StructPointer[ThreadState]) -> int:
return api_binding_base(API_FUNCS["_PyErr_CheckSignalsTstate"], tstate)
class _PyInterpreterState(_CallBase):
"""Namespace containing API functions prefixed with `_PyInterpreterState_`"""
# _PyInterpreterState_RequireIDRef
@staticmethod
def require_id_ref(interp: StructPointer[InterpreterState], i: int) -> None:
return api_binding_base(
API_FUNCS["_PyInterpreterState_RequireIDRef"], interp, i
)
class _PyBytesWriter(_CallBase):
"""Namespace containing API functions prefixed with `_PyBytesWriter_`"""
# _PyBytesWriter_WriteBytes
@staticmethod
def write_bytes(writer: PointerLike, str: PointerLike, bytes: int) -> PointerLike:
return api_binding_base(
API_FUNCS["_PyBytesWriter_WriteBytes"], writer, str, bytes
)
class _PyEval(_CallBase):
"""Namespace containing API functions prefixed with `_PyEval_`"""
# _PyEval_SetTrace
@staticmethod
def set_trace(tstate: StructPointer[ThreadState], func: PyObjectLike) -> int:
return api_binding_base(
API_FUNCS["_PyEval_SetTrace"], tstate, _deref_maybe(func)
)
# _PyEval_GetCoroutineOriginTrackingDepth
@staticmethod
def get_coroutine_origin_tracking_depth() -> int:
return api_binding_base(
API_FUNCS["_PyEval_GetCoroutineOriginTrackingDepth"],
)
# _PyEval_GetAsyncGenFirstiter
@staticmethod
def get_async_gen_firstiter() -> PyObjectLike:
return api_binding_base(
API_FUNCS["_PyEval_GetAsyncGenFirstiter"],
)
# _PyEval_GetAsyncGenFinalizer
@staticmethod
def get_async_gen_finalizer() -> PyObjectLike:
return api_binding_base(
API_FUNCS["_PyEval_GetAsyncGenFinalizer"],
)
# _PyEval_EvalFrameDefault
@staticmethod
def eval_frame_default(
tstate: StructPointer[ThreadState], f: StructPointer[FrameObject], exc: int
) -> PyObjectLike:
return api_binding_base(API_FUNCS["_PyEval_EvalFrameDefault"], tstate, f, exc)
# _PyEval_SetSwitchInterval
@staticmethod
def set_switch_interval(microseconds: int) -> None:
return api_binding_base(API_FUNCS["_PyEval_SetSwitchInterval"], microseconds)
# _PyEval_GetSwitchInterval
@staticmethod
def get_switch_interval() -> int:
return api_binding_base(
API_FUNCS["_PyEval_GetSwitchInterval"],
)
class _PyDictView(_CallBase):
"""Namespace containing API functions prefixed with `_PyDictView_`"""
# _PyDictView_Intersect
@staticmethod
def intersect(slf: PyObjectLike, other: PyObjectLike) -> PyObjectLike:
return api_binding_base(
API_FUNCS["_PyDictView_Intersect"], _deref_maybe(slf), _deref_maybe(other)
)
class _PyRun(_CallBase):
"""Namespace containing API functions prefixed with `_PyRun_`"""
# _PyRun_SimpleFileObject
@staticmethod
def simple_file_object(
fp: PointerLike, filename: PyObjectLike, closeit: int
) -> int:
return api_binding_base(
API_FUNCS["_PyRun_SimpleFileObject"], fp, _deref_maybe(filename), closeit
)
class _PySys(_CallBase):
"""Namespace containing API functions prefixed with `_PySys_`"""
# _PySys_GetObjectId
@staticmethod
def get_object_id() -> PyObjectLike:
return api_binding_base(
API_FUNCS["_PySys_GetObjectId"],
)
class _PyTuple(_CallBase):
"""Namespace containing API functions prefixed with `_PyTuple_`"""
# _PyTuple_DebugMallocStats
@staticmethod
def debug_malloc_stats(out: PointerLike) -> None:
return api_binding_base(API_FUNCS["_PyTuple_DebugMallocStats"], out)
class _PyNumber(_CallBase):
"""Namespace containing API functions prefixed with `_PyNumber_`"""
# _PyNumber_Index
@staticmethod
def index(o: PyObjectLike) -> PyObjectLike:
return api_binding_base(API_FUNCS["_PyNumber_Index"], _deref_maybe(o))
class _PyAST(_CallBase):
"""Namespace containing API functions prefixed with `_PyAST_`"""
# _PyAST_Compile
@staticmethod
def compile(mod: PyObjectLike, filename: int) -> StructPointer[CodeObject]:
return api_binding_base(
API_FUNCS["_PyAST_Compile"], _deref_maybe(mod), filename
)
class _PyStructSequence(_CallBase):
"""Namespace containing API functions prefixed with `_PyStructSequence_`"""
# _PyStructSequence_InitType
@staticmethod
def init_type(type: StructPointer[TypeObject], desc: int) -> int:
return api_binding_base(API_FUNCS["_PyStructSequence_InitType"], type, desc)
class _PyObject(_CallBase):
"""Namespace containing API functions prefixed with `_PyObject_`"""
# _PyObject_Call_Prepend
@staticmethod
def call_prepend(
tstate: StructPointer[ThreadState],
callable: PyObjectLike,
obj: PyObjectLike,
args: PyObjectLike,
kwargs: PyObjectLike,
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["_PyObject_Call_Prepend"],
tstate,
_deref_maybe(callable),
_deref_maybe(obj),
_deref_maybe(args),
_deref_maybe(kwargs),
)
# _PyObject_FastCallDictTstate
@staticmethod
def fast_call_dict_tstate(
tstate: StructPointer[ThreadState],
callable: PyObjectLike,
args: PointerLike,
nargsf: int,
kwargs: PyObjectLike,
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["_PyObject_FastCallDictTstate"],
tstate,
_deref_maybe(callable),
args,
nargsf,
_deref_maybe(kwargs),
)
# _PyObject_Call
@staticmethod
def call(
tstate: StructPointer[ThreadState],
callable: PyObjectLike,
args: PyObjectLike,
kwargs: PyObjectLike,
) -> PyObjectLike:
return api_binding_base(
API_FUNCS["_PyObject_Call"],
tstate,
_deref_maybe(callable),
_deref_maybe(args),
_deref_maybe(kwargs),
)
class _PyType(_CallBase):
"""Namespace containing API functions prefixed with `_PyType_`"""
# _PyType_CheckConsistency
@staticmethod
def check_consistency(type: StructPointer[TypeObject]) -> int:
return api_binding_base(API_FUNCS["_PyType_CheckConsistency"], type)
class _PyDict(_CallBase):
"""Namespace containing API functions prefixed with `_PyDict_`"""
# _PyDict_CheckConsistency
@staticmethod
def check_consistency(mp: PyObjectLike, check_content: int) -> int:
return api_binding_base(
API_FUNCS["_PyDict_CheckConsistency"], _deref_maybe(mp), check_content
)