Crate pyo3_ffi

Expand description

Raw FFI declarations for Python’s C API.

PyO3 can be used to write native Python modules or run Python code and modules from Rust.

This crate just provides low level bindings to the Python interpreter. It is meant for advanced users only - regular PyO3 users shouldn’t need to interact with this crate at all.

The contents of this crate are not documented here, as it would entail basically copying the documentation from CPython. Consult the Python/C API Reference Manual for up-to-date documentation.

§Safety

The functions in this crate lack individual safety documentation, but generally the following apply:

Pointer arguments have to point to a valid Python object of the correct type, although null pointers are sometimes valid input.
The vast majority can only be used safely while the GIL is held.
Some functions have additional safety requirements, consult the Python/C API Reference Manual for more information.

§Feature flags

PyO3 uses feature flags to enable you to opt-in to additional functionality. For a detailed description, see the Features chapter of the guide.

§Optional feature flags

The following features customize PyO3’s behavior:

abi3: Restricts PyO3’s API to a subset of the full Python API which is guaranteed by PEP 384 to be forward-compatible with future Python versions.
extension-module: This will tell the linker to keep the Python symbols unresolved, so that your module can also be used with statically linked Python interpreters. Use this feature when building an extension module.

§`rustc` environment flags

PyO3 uses rustc’s --cfg flags to enable or disable code used for different Python versions. If you want to do this for your own crate, you can do so with the pyo3-build-config crate.

Py_3_7, Py_3_8, Py_3_9, Py_3_10, Py_3_11, Py_3_12, Py_3_13: Marks code that is only enabled when compiling for a given minimum Python version.
Py_LIMITED_API: Marks code enabled when the abi3 feature flag is enabled.
Py_GIL_DISABLED: Marks code that runs only in the free-threaded build of CPython.
PyPy - Marks code enabled when compiling for PyPy.
GraalPy - Marks code enabled when compiling for GraalPy.

Additionally, you can query for the values Py_DEBUG, Py_REF_DEBUG, Py_TRACE_REFS, and COUNT_ALLOCS from py_sys_config to query for the corresponding C build-time defines. For example, to conditionally define debug code using Py_DEBUG, you could do:

#[cfg(py_sys_config = "Py_DEBUG")]
println!("only runs if python was compiled with Py_DEBUG")

To use these attributes, add pyo3-build-config as a build dependency in your Cargo.toml:

[build-dependencies]
pyo3-build-config ="0.24.0"

And then either create a new build.rs file in the project root or modify the existing build.rs file to call use_pyo3_cfgs():

fn main() {
    pyo3_build_config::use_pyo3_cfgs();
}

§Minimum supported Rust and Python versions

pyo3-ffi supports the following Python distributions:

CPython 3.7 or greater
PyPy 7.3 (Python 3.9+)
GraalPy 24.0 or greater (Python 3.10+)

§Example: Building Python Native modules

PyO3 can be used to generate a native Python module. The easiest way to try this out for the first time is to use maturin. maturin is a tool for building and publishing Rust-based Python packages with minimal configuration. The following steps set up some files for an example Python module, install maturin, and then show how to build and import the Python module.

First, create a new folder (let’s call it string_sum) containing the following two files:

Cargo.toml

[lib]
name = "string_sum"
# "cdylib" is necessary to produce a shared library for Python to import from.
#
# Downstream Rust code (including code in `bin/`, `examples/`, and `tests/`) will not be able
# to `use string_sum;` unless the "rlib" or "lib" crate type is also included, e.g.:
# crate-type = ["cdylib", "rlib"]
crate-type = ["cdylib"]

[dependencies.pyo3-ffi]
version = "0.24.0"
features = ["extension-module"]

[build-dependencies]
# This is only necessary if you need to configure your build based on
# the Python version or the compile-time configuration for the interpreter.
pyo3_build_config = "0.24.0"

If you need to use conditional compilation based on Python version or how Python was compiled, you need to add pyo3-build-config as a build-dependency in your Cargo.toml as in the example above and either create a new build.rs file or modify an existing one so that pyo3_build_config::use_pyo3_cfgs() gets called at build time:

build.rs

fn main() {
    pyo3_build_config::use_pyo3_cfgs()
}

src/lib.rs

use std::os::raw::{c_char, c_long};
use std::ptr;

use pyo3_ffi::*;

static mut MODULE_DEF: PyModuleDef = PyModuleDef {
    m_base: PyModuleDef_HEAD_INIT,
    m_name: c_str!("string_sum").as_ptr(),
    m_doc: c_str!("A Python module written in Rust.").as_ptr(),
    m_size: 0,
    m_methods: unsafe { METHODS as *const [PyMethodDef] as *mut PyMethodDef },
    m_slots: std::ptr::null_mut(),
    m_traverse: None,
    m_clear: None,
    m_free: None,
};

static mut METHODS: &[PyMethodDef] = &[
    PyMethodDef {
        ml_name: c_str!("sum_as_string").as_ptr(),
        ml_meth: PyMethodDefPointer {
            PyCFunctionFast: sum_as_string,
        },
        ml_flags: METH_FASTCALL,
        ml_doc: c_str!("returns the sum of two integers as a string").as_ptr(),
    },
    // A zeroed PyMethodDef to mark the end of the array.
    PyMethodDef::zeroed(),
];

// The module initialization function, which must be named `PyInit_<your_module>`.
#[allow(non_snake_case)]
#[no_mangle]
pub unsafe extern "C" fn PyInit_string_sum() -> *mut PyObject {
    let module = PyModule_Create(ptr::addr_of_mut!(MODULE_DEF));
    if module.is_null() {
        return module;
    }
    #[cfg(Py_GIL_DISABLED)]
    {
        if PyUnstable_Module_SetGIL(module, Py_MOD_GIL_NOT_USED) < 0 {
            Py_DECREF(module);
            return std::ptr::null_mut();
        }
    }
    module
}

/// A helper to parse function arguments
/// If we used PyO3's proc macros they'd handle all of this boilerplate for us :)
unsafe fn parse_arg_as_i32(obj: *mut PyObject, n_arg: usize) -> Option<i32> {
    if PyLong_Check(obj) == 0 {
        let msg = format!(
            "sum_as_string expected an int for positional argument {}\0",
            n_arg
        );
        PyErr_SetString(PyExc_TypeError, msg.as_ptr().cast::<c_char>());
        return None;
    }

    // Let's keep the behaviour consistent on platforms where `c_long` is bigger than 32 bits.
    // In particular, it is an i32 on Windows but i64 on most Linux systems
    let mut overflow = 0;
    let i_long: c_long = PyLong_AsLongAndOverflow(obj, &mut overflow);

    #[allow(irrefutable_let_patterns)] // some platforms have c_long equal to i32
    if overflow != 0 {
        raise_overflowerror(obj);
        None
    } else if let Ok(i) = i_long.try_into() {
        Some(i)
    } else {
        raise_overflowerror(obj);
        None
    }
}

unsafe fn raise_overflowerror(obj: *mut PyObject) {
    let obj_repr = PyObject_Str(obj);
    if !obj_repr.is_null() {
        let mut size = 0;
        let p = PyUnicode_AsUTF8AndSize(obj_repr, &mut size);
        if !p.is_null() {
            let s = std::str::from_utf8_unchecked(std::slice::from_raw_parts(
                p.cast::<u8>(),
                size as usize,
            ));
            let msg = format!("cannot fit {} in 32 bits\0", s);

            PyErr_SetString(PyExc_OverflowError, msg.as_ptr().cast::<c_char>());
        }
        Py_DECREF(obj_repr);
    }
}

pub unsafe extern "C" fn sum_as_string(
    _self: *mut PyObject,
    args: *mut *mut PyObject,
    nargs: Py_ssize_t,
) -> *mut PyObject {
    if nargs != 2 {
        PyErr_SetString(
            PyExc_TypeError,
            c_str!("sum_as_string expected 2 positional arguments").as_ptr(),
        );
        return std::ptr::null_mut();
    }

    let (first, second) = (*args, *args.add(1));

    let first = match parse_arg_as_i32(first, 1) {
        Some(x) => x,
        None => return std::ptr::null_mut(),
    };
    let second = match parse_arg_as_i32(second, 2) {
        Some(x) => x,
        None => return std::ptr::null_mut(),
    };

    match first.checked_add(second) {
        Some(sum) => {
            let string = sum.to_string();
            PyUnicode_FromStringAndSize(string.as_ptr().cast::<c_char>(), string.len() as isize)
        }
        None => {
            PyErr_SetString(
                PyExc_OverflowError,
                c_str!("arguments too large to add").as_ptr(),
            );
            std::ptr::null_mut()
        }
    }
}

With those two files in place, now maturin needs to be installed. This can be done using Python’s package manager pip. First, load up a new Python virtualenv, and install maturin into it:

$ cd string_sum
$ python -m venv .env
$ source .env/bin/activate
$ pip install maturin

Now build and execute the module:

$ maturin develop
# lots of progress output as maturin runs the compilation...
$ python
>>> import string_sum
>>> string_sum.sum_as_string(5, 20)
'25'

As well as with maturin, it is possible to build using setuptools-rust or manually. Both offer more flexibility than maturin but require further configuration.

This example stores the module definition statically and uses the PyModule_Create function in the CPython C API to register the module. This is the “old” style for registering modules and has the limitation that it cannot support subinterpreters. You can also create a module using the new multi-phase initialization API that does support subinterpreters. See the sequential project located in the examples directory at the root of the pyo3-ffi crate for a worked example of how to this using pyo3-ffi.

§Using Python from Rust

To embed Python into a Rust binary, you need to ensure that your Python installation contains a shared library. The following steps demonstrate how to ensure this (for Ubuntu).

To install the Python shared library on Ubuntu:

sudo apt install python3-dev

While most projects use the safe wrapper provided by pyo3, you can take a look at the orjson library as an example on how to use pyo3-ffi directly. For those well versed in C and Rust the tutorials from the CPython documentation can be easily converted to rust as well.

Re-exports§

pub use crate::_PyWeakReference as PyWeakReference;
pub use self::marshal::*;

Modules§

compat: C API Compatibility Shims
marshal
structmemberDeprecated

Macros§

c_str: This is a helper macro to create a &'static CStr.

Structs§

PyASCIIObject
PyArena
PyAsyncMethods
PyBaseExceptionObject
PyBufferProcs
PyByteArrayObject
PyBytesObject
PyCodeObject
PyCompactUnicodeObject
PyCompilerFlags
PyComplexObject
PyConfig
PyDateTime_CAPI
PyDateTime_Date: Structure representing a datetime.date
PyDateTime_DateTime: Structure representing a datetime.datetime.
PyDateTime_Delta: Structure representing a datetime.timedelta.
PyDateTime_Time: Structure representing a datetime.time.
PyDescrObject
PyDictKeysObject
PyDictObject
PyFloatObject
PyFrameObject
PyFunctionObject
PyFutureFeatures
PyGenObject
PyGetSetDef: Represents the PyGetSetDef structure.
PyGetSetDescrObject
PyHash_FuncDef
PyHeapTypeObject
PyImportErrorObject
PyInterpreterState
PyListObject
PyLongObject
PyMappingMethods
PyMemAllocatorEx
PyMemberDef: Represents the PyMemberDef structure.
PyMemberDescrObject
PyMethodDef: Represents the PyMethodDef structure.
PyMethodDescrObject
PyModuleDef
PyModuleDef_Base
PyModuleDef_Slot
PyNumberMethods
PyOSErrorObject
PyObject
PyObjectArenaAllocator
PyPreConfig
PySequenceMethods
PySetObject
PySliceObject
PyStatus
PyStopIterationObject
PyStructSequence_Desc
PyStructSequence_Field
PySyntaxErrorObject
PySystemExitObject
PyThreadState
PyTryBlock
PyTupleObject
PyTypeObject
PyType_Slot
PyType_Spec
PyUnicodeErrorObject
PyUnicodeObject
PyVarObject
PyWideStringList
PyWrapperDescrObject
Py_buffer
Py_complex
_PyDateTime_BaseDateTime: Structure representing a datetime.datetime without a tzinfo member.
_PyDateTime_BaseTime: Structure representing a datetime.time without a tzinfo member.
_PyErr_StackItem
_PyOpcache
_PyWeakReference
_frozen
_inittab
_mod
_node
setentry
symtable
wrapperbase

Enums§

PyGILState_STATE
PyMemAllocatorDomain
_PyStatus_TYPE

Constants§

CO_ASYNC_GENERATOR
CO_COROUTINE
CO_FUTURE_ABSOLUTE_IMPORT
CO_FUTURE_BARRY_AS_BDFL
CO_FUTURE_DIVISION
CO_FUTURE_GENERATOR_STOP
CO_FUTURE_PRINT_FUNCTION
CO_FUTURE_UNICODE_LITERALS
CO_FUTURE_WITH_STATEMENT
CO_GENERATOR
CO_ITERABLE_COROUTINE
CO_MAXBLOCKS
CO_NESTED
CO_NEWLOCALS
CO_NOFREE
CO_OPTIMIZED
CO_VARARGS
CO_VARKEYWORDS
FUTURE_ABSOLUTE_IMPORT
FUTURE_BARRY_AS_BDFL
FUTURE_DIVISION
FUTURE_GENERATORS
FUTURE_GENERATOR_STOP
FUTURE_NESTED_SCOPES
FUTURE_PRINT_FUNCTION
FUTURE_UNICODE_LITERALS
FUTURE_WITH_STATEMENT
MAX_CO_EXTRA_USERS
METH_CLASS
METH_COEXIST
METH_FASTCALL
METH_KEYWORDS
METH_NOARGS
METH_O
METH_STATIC
METH_VARARGS
PYOS_STACK_MARGIN
PYTHON_ABI_VERSION
PYTHON_API_VERSION
PY_BIG_ENDIAN
PY_ITERSEARCH_CONTAINS
PY_ITERSEARCH_COUNT
PY_ITERSEARCH_INDEX
PY_LITTLE_ENDIAN
PY_SSIZE_T_MAX
PY_SSIZE_T_MIN
PY_STDIOTEXTMODE
PY_VECTORCALL_ARGUMENTS_OFFSET
PyBUF_ANY_CONTIGUOUS
PyBUF_CONTIG
PyBUF_CONTIG_RO
PyBUF_C_CONTIGUOUS
PyBUF_FORMAT
PyBUF_FULL
PyBUF_FULL_RO
PyBUF_F_CONTIGUOUS
PyBUF_INDIRECT
PyBUF_MAX_NDIM: Maximum number of dimensions
PyBUF_ND
PyBUF_READ
PyBUF_RECORDS
PyBUF_RECORDS_RO
PyBUF_SIMPLE
PyBUF_STRIDED
PyBUF_STRIDED_RO
PyBUF_STRIDES
PyBUF_WRITABLE
PyBUF_WRITE
PyBUF_WRITEABLE
PyDateTime_CAPSULE_NAME
PyModuleDef_HEAD_INIT
PyObject_HEAD_INIT
PySet_MINSIZE
PyTrace_CALL
PyTrace_C_CALL
PyTrace_C_EXCEPTION
PyTrace_C_RETURN
PyTrace_EXCEPTION
PyTrace_LINE
PyTrace_OPCODE
PyTrace_RETURN
PyUnicode_1BYTE_KIND
PyUnicode_2BYTE_KIND
PyUnicode_4BYTE_KIND
PyUnicode_WCHAR_KINDDeprecated
PyWrapperFlag_KEYWORDS
Py_CLEANUP_SUPPORTED
Py_DTSF_ADD_DOT_0
Py_DTSF_ALT
Py_DTSF_SIGN
Py_DTST_FINITE
Py_DTST_INFINITE
Py_DTST_NAN
Py_EQ
Py_GE
Py_GT
Py_HASH_EXTERNAL
Py_HASH_FNV
Py_HASH_SIPHASH24
Py_LE
Py_LT
Py_NE
Py_PRINT_RAW
Py_READONLY
Py_RELATIVE_OFFSET
Py_TPFLAGS_BASETYPE: Set if the type allows subclassing
Py_TPFLAGS_BASE_EXC_SUBCLASS
Py_TPFLAGS_BYTES_SUBCLASS
Py_TPFLAGS_DEFAULT
Py_TPFLAGS_DICT_SUBCLASS
Py_TPFLAGS_HAVE_FINALIZE
Py_TPFLAGS_HAVE_GC: Objects support garbage collection (see objimp.h)
Py_TPFLAGS_HAVE_VECTORCALL: Set if the type implements the vectorcall protocol (PEP 590)
Py_TPFLAGS_HAVE_VERSION_TAG
Py_TPFLAGS_HEAPTYPE: Set if the type object is dynamically allocated
Py_TPFLAGS_IS_ABSTRACT
Py_TPFLAGS_LIST_SUBCLASS
Py_TPFLAGS_LONG_SUBCLASS
Py_TPFLAGS_METHOD_DESCRIPTOR
Py_TPFLAGS_READY: Set if the type is ‘ready’ – fully initialized
Py_TPFLAGS_READYING: Set while the type is being ‘readied’, to prevent recursive ready calls
Py_TPFLAGS_TUPLE_SUBCLASS
Py_TPFLAGS_TYPE_SUBCLASS
Py_TPFLAGS_UNICODE_SUBCLASS
Py_TPFLAGS_VALID_VERSION_TAG
Py_T_BOOL
Py_T_BYTE
Py_T_CHAR
Py_T_DOUBLE
Py_T_FLOAT
Py_T_INT
Py_T_LONG
Py_T_LONGLONG
Py_T_OBJECT_EX
Py_T_PYSSIZET
Py_T_SHORT
Py_T_STRING
Py_T_STRING_INPLACE
Py_T_UBYTE
Py_T_UINT
Py_T_ULONG
Py_T_ULONGLONG
Py_T_USHORT
Py_UNICODE_REPLACEMENT_CHARACTER
Py_am_aiter
Py_am_anext
Py_am_await
Py_bf_getbuffer
Py_bf_releasebuffer
Py_eval_input
Py_file_input
Py_func_type_input
Py_mod_create
Py_mod_exec
Py_mp_ass_subscript
Py_mp_length
Py_mp_subscript
Py_nb_absolute
Py_nb_add
Py_nb_and
Py_nb_bool
Py_nb_divmod
Py_nb_float
Py_nb_floor_divide
Py_nb_index
Py_nb_inplace_add
Py_nb_inplace_and
Py_nb_inplace_floor_divide
Py_nb_inplace_lshift
Py_nb_inplace_matrix_multiply
Py_nb_inplace_multiply
Py_nb_inplace_or
Py_nb_inplace_power
Py_nb_inplace_remainder
Py_nb_inplace_rshift
Py_nb_inplace_subtract
Py_nb_inplace_true_divide
Py_nb_inplace_xor
Py_nb_int
Py_nb_invert
Py_nb_lshift
Py_nb_matrix_multiply
Py_nb_multiply
Py_nb_negative
Py_nb_or
Py_nb_positive
Py_nb_power
Py_nb_remainder
Py_nb_rshift
Py_nb_subtract
Py_nb_true_divide
Py_nb_xor
Py_single_input
Py_sq_ass_item
Py_sq_concat
Py_sq_contains
Py_sq_inplace_concat
Py_sq_inplace_repeat
Py_sq_item
Py_sq_length
Py_sq_repeat
Py_tp_alloc
Py_tp_base
Py_tp_bases
Py_tp_call
Py_tp_clear
Py_tp_dealloc
Py_tp_del
Py_tp_descr_get
Py_tp_descr_set
Py_tp_doc
Py_tp_finalize
Py_tp_free
Py_tp_getattr
Py_tp_getattro
Py_tp_getset
Py_tp_hash
Py_tp_init
Py_tp_is_gc
Py_tp_iter
Py_tp_iternext
Py_tp_members
Py_tp_methods
Py_tp_new
Py_tp_repr
Py_tp_richcompare
Py_tp_setattr
Py_tp_setattro
Py_tp_str
Py_tp_traverse
SSTATE_INTERNED_IMMORTAL
SSTATE_INTERNED_MORTAL
SSTATE_NOT_INTERNED
_PyHASH_MULTIPLIER
_Py_T_NONEDeprecated
_Py_T_OBJECTDeprecated
_Py_WRITE_RESTRICTEDDeprecated

Statics§

PyAsyncGen_Type^⚠
PyBaseObject_Type^⚠: built-in ‘object’
PyBool_Type^⚠
PyByteArrayIter_Type^⚠
PyByteArray_Type^⚠
PyBytesIter_Type^⚠
PyBytes_Type^⚠
PyCFunction_Type^⚠
PyCallIter_Type^⚠
PyCapsule_Type^⚠
PyClassMethodDescr_Type^⚠
PyCode_Type^⚠
PyComplex_Type^⚠
PyContextToken_Type^⚠
PyContextVar_Type^⚠
PyContext_Type^⚠
PyCoro_Type^⚠
PyDictItems_Type^⚠
PyDictIterItem_Type^⚠
PyDictIterKey_Type^⚠
PyDictIterValue_Type^⚠
PyDictKeys_Type^⚠
PyDictProxy_Type^⚠
PyDictRevIterItem_Type^⚠
PyDictRevIterKey_Type^⚠
PyDictRevIterValue_Type^⚠
PyDictValues_Type^⚠
PyDict_Type^⚠
PyEllipsis_Type^⚠
PyEnum_Type^⚠
PyExc_ArithmeticError^⚠
PyExc_AssertionError^⚠
PyExc_AttributeError^⚠
PyExc_BaseException^⚠
PyExc_BlockingIOError^⚠
PyExc_BrokenPipeError^⚠
PyExc_BufferError^⚠
PyExc_BytesWarning^⚠
PyExc_ChildProcessError^⚠
PyExc_ConnectionAbortedError^⚠
PyExc_ConnectionError^⚠
PyExc_ConnectionRefusedError^⚠
PyExc_ConnectionResetError^⚠
PyExc_DeprecationWarning^⚠
PyExc_EOFError^⚠
PyExc_EnvironmentError^⚠
PyExc_Exception^⚠
PyExc_FileExistsError^⚠
PyExc_FileNotFoundError^⚠
PyExc_FloatingPointError^⚠
PyExc_FutureWarning^⚠
PyExc_GeneratorExit^⚠
PyExc_IOError^⚠
PyExc_ImportError^⚠
PyExc_ImportWarning^⚠
PyExc_IndentationError^⚠
PyExc_IndexError^⚠
PyExc_InterruptedError^⚠
PyExc_IsADirectoryError^⚠
PyExc_KeyError^⚠
PyExc_KeyboardInterrupt^⚠
PyExc_LookupError^⚠
PyExc_MemoryError^⚠
PyExc_ModuleNotFoundError^⚠
PyExc_NameError^⚠
PyExc_NotADirectoryError^⚠
PyExc_NotImplementedError^⚠
PyExc_OSError^⚠
PyExc_OverflowError^⚠
PyExc_PendingDeprecationWarning^⚠
PyExc_PermissionError^⚠
PyExc_ProcessLookupError^⚠
PyExc_RecursionError^⚠
PyExc_RecursionErrorInst^⚠
PyExc_ReferenceError^⚠
PyExc_ResourceWarning^⚠
PyExc_RuntimeError^⚠
PyExc_RuntimeWarning^⚠
PyExc_StopAsyncIteration^⚠
PyExc_StopIteration^⚠
PyExc_SyntaxError^⚠
PyExc_SyntaxWarning^⚠
PyExc_SystemError^⚠
PyExc_SystemExit^⚠
PyExc_TabError^⚠
PyExc_TimeoutError^⚠
PyExc_TypeError^⚠
PyExc_UnboundLocalError^⚠
PyExc_UnicodeDecodeError^⚠
PyExc_UnicodeEncodeError^⚠
PyExc_UnicodeError^⚠
PyExc_UnicodeTranslateError^⚠
PyExc_UnicodeWarning^⚠
PyExc_UserWarning^⚠
PyExc_ValueError^⚠
PyExc_Warning^⚠
PyExc_ZeroDivisionError^⚠
PyFilter_Type^⚠
PyFloat_Type^⚠
PyFrame_Type^⚠
PyFrozenSet_Type^⚠
PyFunction_Type^⚠
PyGen_Type^⚠
PyGetSetDescr_Type^⚠
PyImport_FrozenModules^⚠
PyImport_Inittab^⚠
PyListIter_Type^⚠
PyListRevIter_Type^⚠
PyList_Type^⚠
PyLongRangeIter_Type^⚠
PyLong_Type^⚠
PyMap_Type^⚠
PyMemberDescr_Type^⚠
PyMemoryView_Type^⚠
PyMethodDescr_Type^⚠
PyModuleDef_Type^⚠
PyModule_Type^⚠
PyProperty_Type^⚠
PyRangeIter_Type^⚠
PyRange_Type^⚠
PyReversed_Type^⚠
PySeqIter_Type^⚠
PySetIter_Type^⚠
PySet_Type^⚠
PySlice_Type^⚠
PySuper_Type^⚠: built-in ‘super’
PyTraceBack_Type^⚠
PyTupleIter_Type^⚠
PyTuple_Type^⚠
PyType_Type^⚠: built-in ‘type’
PyUnicodeIter_Type^⚠
PyUnicode_Type^⚠
PyWrapperDescr_Type^⚠
PyZip_Type^⚠
Py_BytesWarningFlag^⚠Deprecated
Py_DebugFlag^⚠Deprecated
Py_DontWriteBytecodeFlag^⚠Deprecated
Py_FileSystemDefaultEncodeErrors^⚠Deprecated
Py_FileSystemDefaultEncoding^⚠Deprecated
Py_FrozenFlag^⚠Deprecated
Py_HasFileSystemDefaultEncoding^⚠Deprecated
Py_HashRandomizationFlag^⚠
Py_IgnoreEnvironmentFlag^⚠Deprecated
Py_InspectFlag^⚠Deprecated
Py_InteractiveFlag^⚠Deprecated
Py_IsolatedFlag^⚠Deprecated
Py_NoSiteFlag^⚠Deprecated
Py_NoUserSiteDirectory^⚠Deprecated
Py_OptimizeFlag^⚠Deprecated
Py_QuietFlag^⚠Deprecated
Py_UnbufferedStdioFlag^⚠Deprecated
Py_UseClassExceptionsFlag^⚠Deprecated
Py_VerboseFlag^⚠Deprecated
_PyCoroWrapper_Type^⚠
_PyManagedBuffer_Type^⚠
_PyMethodWrapper_Type^⚠
_PySet_Dummy^⚠
_PyWeakref_CallableProxyType^⚠
_PyWeakref_ProxyType^⚠
_PyWeakref_RefType^⚠

Functions§

PyAST_CompileEx^⚠
PyAST_CompileObject^⚠
PyAnySet_Check^⚠
PyAnySet_CheckExact^⚠
PyArg_Parse^⚠
PyArg_ParseTuple^⚠
PyArg_ParseTupleAndKeywords^⚠
PyArg_UnpackTuple^⚠
PyArg_ValidateKeywordArguments^⚠
PyAsyncGen_CheckExact^⚠
PyBool_Check^⚠
PyBool_FromLong^⚠
PyBuffer_FillContiguousStrides^⚠
PyBuffer_FillInfo^⚠
PyBuffer_FromContiguous^⚠
PyBuffer_GetPointer^⚠
PyBuffer_IsContiguous^⚠
PyBuffer_Release^⚠
PyBuffer_SizeFromFormat^⚠
PyBuffer_ToContiguous^⚠
PyByteArray_AsString^⚠
PyByteArray_Check^⚠
PyByteArray_CheckExact^⚠
PyByteArray_Concat^⚠
PyByteArray_FromObject^⚠
PyByteArray_FromStringAndSize^⚠
PyByteArray_Resize^⚠
PyByteArray_Size^⚠
PyBytes_AsString^⚠
PyBytes_AsStringAndSize^⚠
PyBytes_Check^⚠
PyBytes_CheckExact^⚠
PyBytes_Concat^⚠
PyBytes_ConcatAndDel^⚠
PyBytes_DecodeEscape^⚠
PyBytes_FromFormat^⚠
PyBytes_FromObject^⚠
PyBytes_FromString^⚠
PyBytes_FromStringAndSize^⚠
PyBytes_Repr^⚠
PyBytes_Size^⚠
PyCFunction_Call^⚠
PyCFunction_Check^⚠
PyCFunction_ClearFreeList^⚠
PyCFunction_GetFlags^⚠
PyCFunction_GetFunction^⚠
PyCFunction_GetSelf^⚠
PyCFunction_New^⚠
PyCFunction_NewEx^⚠
PyCallIter_Check^⚠
PyCallIter_New^⚠
PyCallable_Check^⚠
PyCapsule_CheckExact^⚠
PyCapsule_GetContext^⚠
PyCapsule_GetDestructor^⚠
PyCapsule_GetName^⚠
PyCapsule_GetPointer^⚠
PyCapsule_Import^⚠
PyCapsule_IsValid^⚠
PyCapsule_New^⚠
PyCapsule_SetContext^⚠
PyCapsule_SetDestructor^⚠
PyCapsule_SetName^⚠
PyCapsule_SetPointer^⚠
PyCode_Addr2Line^⚠
PyCode_Check^⚠
PyCode_New^⚠
PyCode_NewEmpty^⚠
PyCode_NewWithPosOnlyArgs^⚠
PyCode_Optimize^⚠
PyCodec_BackslashReplaceErrors^⚠
PyCodec_Decode^⚠
PyCodec_Decoder^⚠
PyCodec_Encode^⚠
PyCodec_Encoder^⚠
PyCodec_IgnoreErrors^⚠
PyCodec_IncrementalDecoder^⚠
PyCodec_IncrementalEncoder^⚠
PyCodec_KnownEncoding^⚠
PyCodec_LookupError^⚠
PyCodec_Register^⚠
PyCodec_RegisterError^⚠
PyCodec_ReplaceErrors^⚠
PyCodec_StreamReader^⚠
PyCodec_StreamWriter^⚠
PyCodec_StrictErrors^⚠
PyCodec_XMLCharRefReplaceErrors^⚠
PyCompile_OpcodeStackEffect^⚠
PyCompile_OpcodeStackEffectWithJump^⚠
PyComplex_AsCComplex^⚠
PyComplex_Check^⚠
PyComplex_CheckExact^⚠
PyComplex_FromCComplex^⚠
PyComplex_FromDoubles^⚠
PyComplex_ImagAsDouble^⚠
PyComplex_RealAsDouble^⚠
PyConfig_Clear^⚠
PyConfig_InitIsolatedConfig^⚠
PyConfig_InitPythonConfig^⚠
PyConfig_Read^⚠
PyConfig_SetArgv^⚠
PyConfig_SetBytesArgv^⚠
PyConfig_SetBytesString^⚠
PyConfig_SetString^⚠
PyConfig_SetWideStringList^⚠
PyContextToken_CheckExact^⚠
PyContextVar_CheckExact^⚠
PyContextVar_Get^⚠
PyContextVar_New^⚠
PyContextVar_Reset^⚠
PyContextVar_Set^⚠
PyContext_CheckExact^⚠
PyContext_Copy^⚠
PyContext_CopyCurrent^⚠
PyContext_Enter^⚠
PyContext_Exit^⚠
PyContext_New^⚠
PyCoro_CheckExact^⚠
PyDateTimeAPI^⚠: Returns a pointer to a PyDateTime_CAPI instance
PyDateTime_Check^⚠: Check if op is a PyDateTimeAPI.DateTimeType or subtype.
PyDateTime_CheckExact^⚠: Check if op’s type is exactly PyDateTimeAPI.DateTimeType.
PyDateTime_DATE_GET_FOLD^⚠: Retrieve the fold component of a PyDateTime_DateTime. Returns a signed integer in the interval [0, 1]
PyDateTime_DATE_GET_HOUR^⚠: Retrieve the hour component of a PyDateTime_DateTime. Returns a signed integer in the interval [0, 23]
PyDateTime_DATE_GET_MICROSECOND^⚠: Retrieve the microsecond component of a PyDateTime_DateTime. Returns a signed integer in the interval [0, 999999]
PyDateTime_DATE_GET_MINUTE^⚠: Retrieve the minute component of a PyDateTime_DateTime. Returns a signed integer in the interval [0, 59]
PyDateTime_DATE_GET_SECOND^⚠: Retrieve the second component of a PyDateTime_DateTime. Returns a signed integer in the interval [0, 59]
PyDateTime_DATE_GET_TZINFO^⚠: Retrieve the tzinfo component of a PyDateTime_DateTime. Returns a pointer to a PyObject that should be either NULL or an instance of a datetime.tzinfo subclass.
PyDateTime_DELTA_GET_DAYS^⚠: Retrieve the days component of a PyDateTime_Delta.
PyDateTime_DELTA_GET_MICROSECONDS^⚠: Retrieve the seconds component of a PyDateTime_Delta.
PyDateTime_DELTA_GET_SECONDS^⚠: Retrieve the seconds component of a PyDateTime_Delta.
PyDateTime_FromTimestamp^⚠
PyDateTime_GET_DAY^⚠: Retrieve the day component of a PyDateTime_Date or PyDateTime_DateTime. Returns a signed integer in the interval [1, 31].
PyDateTime_GET_MONTH^⚠: Retrieve the month component of a PyDateTime_Date or PyDateTime_DateTime. Returns a signed integer in the range [1, 12].
PyDateTime_GET_YEAR^⚠: Retrieve the year component of a PyDateTime_Date or PyDateTime_DateTime. Returns a signed integer greater than 0.
PyDateTime_IMPORT^⚠: Populates the PyDateTimeAPI object
PyDateTime_TIME_GET_FOLD^⚠: Retrieve the fold component of a PyDateTime_Time. Returns a signed integer in the interval [0, 1]
PyDateTime_TIME_GET_HOUR^⚠: Retrieve the hour component of a PyDateTime_Time. Returns a signed integer in the interval [0, 23]
PyDateTime_TIME_GET_MICROSECOND^⚠: Retrieve the microsecond component of a PyDateTime_DateTime. Returns a signed integer in the interval [0, 999999]
PyDateTime_TIME_GET_MINUTE^⚠: Retrieve the minute component of a PyDateTime_Time. Returns a signed integer in the interval [0, 59]
PyDateTime_TIME_GET_SECOND^⚠: Retrieve the second component of a PyDateTime_DateTime. Returns a signed integer in the interval [0, 59]
PyDateTime_TIME_GET_TZINFO^⚠: Retrieve the tzinfo component of a PyDateTime_Time. Returns a pointer to a PyObject that should be either NULL or an instance of a datetime.tzinfo subclass.
PyDateTime_TimeZone_UTC^⚠
PyDate_Check^⚠: Type Check macros
PyDate_CheckExact^⚠: Check if op’s type is exactly PyDateTimeAPI.DateType.
PyDate_FromTimestamp^⚠
PyDelta_Check^⚠: Check if op is a PyDateTimeAPI.DetaType or subtype.
PyDelta_CheckExact^⚠: Check if op’s type is exactly PyDateTimeAPI.DeltaType.
PyDescr_NewClassMethod^⚠
PyDescr_NewGetSet^⚠
PyDescr_NewMember^⚠
PyDescr_NewMethod^⚠
PyDictItems_Check^⚠
PyDictKeys_Check^⚠
PyDictProxy_New^⚠
PyDictValues_Check^⚠
PyDictViewSet_Check^⚠
PyDict_Check^⚠
PyDict_CheckExact^⚠
PyDict_Clear^⚠
PyDict_Contains^⚠
PyDict_Copy^⚠
PyDict_DelItem^⚠
PyDict_DelItemString^⚠
PyDict_GetItem^⚠
PyDict_GetItemString^⚠
PyDict_GetItemWithError^⚠
PyDict_Items^⚠
PyDict_Keys^⚠
PyDict_Merge^⚠
PyDict_MergeFromSeq2^⚠
PyDict_New^⚠
PyDict_Next^⚠
PyDict_SetItem^⚠
PyDict_SetItemString^⚠
PyDict_Size^⚠
PyDict_Update^⚠
PyDict_Values^⚠
PyErr_BadArgument^⚠
PyErr_BadInternalCall^⚠
PyErr_CheckSignals^⚠
PyErr_Clear^⚠
PyErr_Display^⚠
PyErr_ExceptionMatches^⚠
PyErr_Fetch^⚠
PyErr_Format^⚠
PyErr_GetExcInfo^⚠
PyErr_GivenExceptionMatches^⚠
PyErr_NewException^⚠
PyErr_NewExceptionWithDoc^⚠
PyErr_NoMemory^⚠
PyErr_NormalizeException^⚠
PyErr_Occurred^⚠
PyErr_Print^⚠
PyErr_PrintEx^⚠
PyErr_ProgramText^⚠
PyErr_ResourceWarning^⚠
PyErr_Restore^⚠
PyErr_SetExcInfo^⚠
PyErr_SetFromErrno^⚠
PyErr_SetFromErrnoWithFilename^⚠
PyErr_SetFromErrnoWithFilenameObject^⚠
PyErr_SetFromErrnoWithFilenameObjects^⚠
PyErr_SetImportError^⚠
PyErr_SetImportErrorSubclass^⚠
PyErr_SetInterrupt^⚠
PyErr_SetNone^⚠
PyErr_SetObject^⚠
PyErr_SetString^⚠
PyErr_SyntaxLocation^⚠
PyErr_SyntaxLocationEx^⚠
PyErr_WarnEx^⚠
PyErr_WarnExplicit^⚠
PyErr_WarnFormat^⚠
PyErr_WriteUnraisable^⚠
PyEval_AcquireLock^⚠
PyEval_AcquireThread^⚠
PyEval_CallFunction^⚠
PyEval_CallMethod^⚠
PyEval_CallObject^⚠
PyEval_CallObjectWithKeywords^⚠
PyEval_EvalCode^⚠
PyEval_EvalCodeEx^⚠
PyEval_EvalFrame^⚠
PyEval_EvalFrameEx^⚠
PyEval_GetBuiltins^⚠
PyEval_GetCallStats^⚠
PyEval_GetFrame^⚠
PyEval_GetFuncDesc^⚠
PyEval_GetFuncName^⚠
PyEval_GetGlobals^⚠
PyEval_GetLocals^⚠
PyEval_InitThreads^⚠
PyEval_ReleaseLock^⚠
PyEval_ReleaseThread^⚠
PyEval_RestoreThread^⚠
PyEval_SaveThread^⚠
PyEval_SetProfile^⚠
PyEval_SetTrace^⚠
PyEval_ThreadsInitialized^⚠
PyExceptionClass_Check^⚠
PyExceptionInstance_Check^⚠
PyExceptionInstance_Class^⚠
PyException_GetCause^⚠
PyException_GetContext^⚠
PyException_GetTraceback^⚠
PyException_SetCause^⚠
PyException_SetContext^⚠
PyException_SetTraceback^⚠
PyFile_FromFd^⚠
PyFile_GetLine^⚠
PyFile_WriteObject^⚠
PyFile_WriteString^⚠
PyFloat_AS_DOUBLE^⚠
PyFloat_AsDouble^⚠
PyFloat_Check^⚠
PyFloat_CheckExact^⚠
PyFloat_FromDouble^⚠
PyFloat_FromString^⚠
PyFloat_GetInfo^⚠
PyFloat_GetMax^⚠
PyFloat_GetMin^⚠
PyFrame_BlockPop^⚠
PyFrame_BlockSetup^⚠
PyFrame_Check^⚠
PyFrame_ClearFreeList^⚠
PyFrame_FastToLocals^⚠
PyFrame_FastToLocalsWithError^⚠
PyFrame_GetLineNumber^⚠
PyFrame_LocalsToFast^⚠
PyFrame_New^⚠
PyFrozenSet_Check^⚠
PyFrozenSet_CheckExact^⚠
PyFrozenSet_New^⚠
PyFunction_Check^⚠
PyFunction_GetAnnotations^⚠
PyFunction_GetClosure^⚠
PyFunction_GetCode^⚠
PyFunction_GetDefaults^⚠
PyFunction_GetGlobals^⚠
PyFunction_GetKwDefaults^⚠
PyFunction_GetModule^⚠
PyFunction_New^⚠
PyFunction_NewWithQualName^⚠
PyFunction_SetAnnotations^⚠
PyFunction_SetClosure^⚠
PyFunction_SetDefaults^⚠
PyFunction_SetKwDefaults^⚠
PyFuture_FromAST^⚠
PyFuture_FromASTObject^⚠
PyGC_Collect^⚠
PyGILState_Check^⚠
PyGILState_Ensure^⚠
PyGILState_GetThisThreadState^⚠
PyGILState_Release^⚠
PyGen_Check^⚠
PyGen_CheckExact^⚠
PyGen_NeedsFinalizing^⚠Deprecated
PyGen_New^⚠
PyHash_GetFuncDef^⚠
PyHeapType_GET_MEMBERS^⚠
PyImport_AddModule^⚠
PyImport_AddModuleObject^⚠
PyImport_AppendInittab^⚠
PyImport_Cleanup^⚠Deprecated
PyImport_ExecCodeModule^⚠
PyImport_ExecCodeModuleEx^⚠
PyImport_ExecCodeModuleObject^⚠
PyImport_ExecCodeModuleWithPathnames^⚠
PyImport_ExtendInittab^⚠
PyImport_GetImporter^⚠
PyImport_GetMagicNumber^⚠
PyImport_GetMagicTag^⚠
PyImport_GetModuleDict^⚠
PyImport_Import^⚠
PyImport_ImportFrozenModule^⚠
PyImport_ImportFrozenModuleObject^⚠
PyImport_ImportModule^⚠
PyImport_ImportModuleEx^⚠
PyImport_ImportModuleLevel^⚠
PyImport_ImportModuleLevelObject^⚠
PyImport_ImportModuleNoBlock^⚠
PyImport_ReloadModule^⚠
PyIndex_Check^⚠
PyInterpreterState_Clear^⚠
PyInterpreterState_Delete^⚠
PyInterpreterState_GetDict^⚠
PyInterpreterState_GetID^⚠
PyInterpreterState_Head^⚠
PyInterpreterState_Main^⚠
PyInterpreterState_New^⚠
PyInterpreterState_Next^⚠
PyInterpreterState_ThreadHead^⚠
PyIter_Check^⚠
PyIter_Next^⚠
PyList_Append^⚠
PyList_AsTuple^⚠
PyList_Check^⚠
PyList_CheckExact^⚠
PyList_GET_ITEM^⚠: Macro, trading safety for speed
PyList_GET_SIZE^⚠
PyList_GetItem^⚠
PyList_GetSlice^⚠
PyList_Insert^⚠
PyList_New^⚠
PyList_Reverse^⚠
PyList_SET_ITEM^⚠: Macro, only to be used to fill in brand new lists
PyList_SetItem^⚠
PyList_SetSlice^⚠
PyList_Size^⚠
PyList_Sort^⚠
PyLong_AsDouble^⚠
PyLong_AsLong^⚠
PyLong_AsLongAndOverflow^⚠
PyLong_AsLongLong^⚠
PyLong_AsLongLongAndOverflow^⚠
PyLong_AsSize_t^⚠
PyLong_AsSsize_t^⚠
PyLong_AsUnsignedLong^⚠
PyLong_AsUnsignedLongLong^⚠
PyLong_AsUnsignedLongLongMask^⚠
PyLong_AsUnsignedLongMask^⚠
PyLong_AsVoidPtr^⚠
PyLong_Check^⚠
PyLong_CheckExact^⚠
PyLong_FromDouble^⚠
PyLong_FromLong^⚠
PyLong_FromLongLong^⚠
PyLong_FromSize_t^⚠
PyLong_FromSsize_t^⚠
PyLong_FromString^⚠
PyLong_FromUnsignedLong^⚠
PyLong_FromUnsignedLongLong^⚠
PyLong_FromVoidPtr^⚠
PyLong_GetInfo^⚠
PyMapping_Check^⚠
PyMapping_DelItem^⚠
PyMapping_DelItemString^⚠
PyMapping_GetItemString^⚠
PyMapping_HasKey^⚠
PyMapping_HasKeyString^⚠
PyMapping_Items^⚠
PyMapping_Keys^⚠
PyMapping_Length^⚠
PyMapping_SetItemString^⚠
PyMapping_Size^⚠
PyMapping_Values^⚠
PyMem_Calloc^⚠
PyMem_Free^⚠
PyMem_GetAllocator^⚠
PyMem_Malloc^⚠
PyMem_RawCalloc^⚠
PyMem_RawFree^⚠
PyMem_RawMalloc^⚠
PyMem_RawRealloc^⚠
PyMem_Realloc^⚠
PyMem_SetAllocator^⚠
PyMem_SetupDebugHooks^⚠
PyMember_GetOne^⚠
PyMember_SetOne^⚠
PyMemoryView_Check^⚠
PyMemoryView_FromBuffer^⚠
PyMemoryView_FromMemory^⚠
PyMemoryView_FromObject^⚠
PyMemoryView_GetContiguous^⚠
PyModuleDef_Init^⚠
PyModule_AddFunctions^⚠
PyModule_AddIntConstant^⚠
PyModule_AddObject^⚠
PyModule_AddStringConstant^⚠
PyModule_Check^⚠
PyModule_CheckExact^⚠
PyModule_Create^⚠
PyModule_Create2^⚠
PyModule_ExecDef^⚠
PyModule_FromDefAndSpec^⚠
PyModule_FromDefAndSpec2^⚠
PyModule_GetDef^⚠
PyModule_GetDict^⚠
PyModule_GetFilename^⚠Deprecated
PyModule_GetFilenameObject^⚠
PyModule_GetName^⚠
PyModule_GetNameObject^⚠
PyModule_GetState^⚠
PyModule_New^⚠
PyModule_NewObject^⚠
PyModule_SetDocString^⚠
PyNode_Compile^⚠
PyNumber_Absolute^⚠
PyNumber_Add^⚠
PyNumber_And^⚠
PyNumber_AsSsize_t^⚠
PyNumber_Check^⚠
PyNumber_Divmod^⚠
PyNumber_Float^⚠
PyNumber_FloorDivide^⚠
PyNumber_InPlaceAdd^⚠
PyNumber_InPlaceAnd^⚠
PyNumber_InPlaceFloorDivide^⚠
PyNumber_InPlaceLshift^⚠
PyNumber_InPlaceMatrixMultiply^⚠
PyNumber_InPlaceMultiply^⚠
PyNumber_InPlaceOr^⚠
PyNumber_InPlacePower^⚠
PyNumber_InPlaceRemainder^⚠
PyNumber_InPlaceRshift^⚠
PyNumber_InPlaceSubtract^⚠
PyNumber_InPlaceTrueDivide^⚠
PyNumber_InPlaceXor^⚠
PyNumber_Index^⚠
PyNumber_Invert^⚠
PyNumber_Long^⚠
PyNumber_Lshift^⚠
PyNumber_MatrixMultiply^⚠
PyNumber_Multiply^⚠
PyNumber_Negative^⚠
PyNumber_Or^⚠
PyNumber_Positive^⚠
PyNumber_Power^⚠
PyNumber_Remainder^⚠
PyNumber_Rshift^⚠
PyNumber_Subtract^⚠
PyNumber_ToBase^⚠
PyNumber_TrueDivide^⚠
PyNumber_Xor^⚠
PyOS_AfterFork^⚠Deprecated
PyOS_AfterFork_Child^⚠
PyOS_AfterFork_Parent^⚠
PyOS_BeforeFork^⚠
PyOS_FSPath^⚠
PyOS_InitInterrupts^⚠Deprecated
PyOS_InterruptOccurred^⚠
PyOS_double_to_string^⚠
PyOS_getsig^⚠
PyOS_setsig^⚠
PyOS_string_to_double^⚠
PyOS_strtol^⚠
PyOS_strtoul^⚠
PyObject_ASCII^⚠
PyObject_AsFileDescriptor^⚠
PyObject_Bytes^⚠
PyObject_Call^⚠
PyObject_CallFinalizer^⚠
PyObject_CallFinalizerFromDealloc^⚠
PyObject_CallFunction^⚠
PyObject_CallFunctionObjArgs^⚠
PyObject_CallMethod^⚠
PyObject_CallMethodObjArgs^⚠
PyObject_CallObject^⚠
PyObject_CallOneArg^⚠
PyObject_Calloc^⚠
PyObject_CheckBuffer^⚠
PyObject_ClearWeakRefs^⚠
PyObject_CopyData^⚠
PyObject_DelAttr^⚠
PyObject_DelAttrString^⚠
PyObject_DelItem^⚠
PyObject_DelItemString^⚠
PyObject_Dir^⚠
PyObject_Format^⚠
PyObject_Free^⚠
PyObject_GC_Del^⚠
PyObject_GC_Track^⚠
PyObject_GC_UnTrack^⚠
PyObject_GET_WEAKREFS_LISTPTR^⚠
PyObject_GenericGetAttr^⚠
PyObject_GenericGetDict^⚠
PyObject_GenericSetAttr^⚠
PyObject_GenericSetDict^⚠
PyObject_GetArenaAllocator^⚠
PyObject_GetAttr^⚠
PyObject_GetAttrString^⚠
PyObject_GetBuffer^⚠
PyObject_GetItem^⚠
PyObject_GetIter^⚠
PyObject_HasAttr^⚠
PyObject_HasAttrString^⚠
PyObject_Hash^⚠
PyObject_HashNotImplemented^⚠
PyObject_IS_GC^⚠
PyObject_Init^⚠
PyObject_InitVar^⚠
PyObject_IsInstance^⚠
PyObject_IsSubclass^⚠
PyObject_IsTrue^⚠
PyObject_Length^⚠
PyObject_LengthHint^⚠
PyObject_Malloc^⚠
PyObject_Not^⚠
PyObject_Print^⚠
PyObject_Realloc^⚠
PyObject_Repr^⚠
PyObject_RichCompare^⚠
PyObject_RichCompareBool^⚠
PyObject_SelfIter^⚠
PyObject_SetArenaAllocator^⚠
PyObject_SetAttr^⚠
PyObject_SetAttrString^⚠
PyObject_SetItem^⚠
PyObject_Size^⚠
PyObject_Str^⚠
PyObject_Type^⚠
PyObject_TypeCheck^⚠
PyObject_Vectorcall^⚠
PyObject_VectorcallDict^⚠
PyParser_ASTFromFile^⚠
PyParser_ASTFromFileObject^⚠
PyParser_ASTFromString^⚠
PyParser_ASTFromStringObject^⚠
PyParser_SimpleParseFile^⚠
PyParser_SimpleParseFileFlags^⚠
PyParser_SimpleParseString^⚠
PyParser_SimpleParseStringFlags^⚠
PyParser_SimpleParseStringFlagsFilename^⚠
PyPreConfig_InitIsolatedConfig^⚠
PyPreConfig_InitPythonConfig^⚠
PyRange_Check^⚠
PyRun_AnyFile^⚠
PyRun_AnyFileEx^⚠
PyRun_AnyFileExFlags^⚠
PyRun_AnyFileFlags^⚠
PyRun_File^⚠
PyRun_FileEx^⚠
PyRun_FileExFlags^⚠
PyRun_FileFlags^⚠
PyRun_InteractiveLoop^⚠
PyRun_InteractiveLoopFlags^⚠
PyRun_InteractiveOne^⚠
PyRun_InteractiveOneFlags^⚠
PyRun_InteractiveOneObject^⚠
PyRun_SimpleFile^⚠
PyRun_SimpleFileEx^⚠
PyRun_SimpleFileExFlags^⚠
PyRun_SimpleString^⚠
PyRun_SimpleStringFlags^⚠
PyRun_String^⚠
PyRun_StringFlags^⚠
PySeqIter_Check^⚠
PySeqIter_New^⚠
PySequence_Check^⚠
PySequence_Concat^⚠
PySequence_Contains^⚠
PySequence_Count^⚠
PySequence_DelItem^⚠
PySequence_DelSlice^⚠
PySequence_Fast^⚠
PySequence_GetItem^⚠
PySequence_GetSlice^⚠
PySequence_In^⚠
PySequence_InPlaceConcat^⚠
PySequence_InPlaceRepeat^⚠
PySequence_Index^⚠
PySequence_Length^⚠
PySequence_List^⚠
PySequence_Repeat^⚠
PySequence_SetItem^⚠
PySequence_SetSlice^⚠
PySequence_Size^⚠
PySequence_Tuple^⚠
PySet_Add^⚠
PySet_Check^⚠
PySet_Clear^⚠
PySet_Contains^⚠
PySet_Discard^⚠
PySet_GET_SIZE^⚠
PySet_New^⚠
PySet_Pop^⚠
PySet_Size^⚠
PySlice_AdjustIndices^⚠
PySlice_Check^⚠
PySlice_GetIndices^⚠
PySlice_GetIndicesEx^⚠
PySlice_New^⚠
PySlice_Unpack^⚠
PyState_AddModule^⚠
PyState_FindModule^⚠
PyState_RemoveModule^⚠
PyStatus_Error^⚠
PyStatus_Exception^⚠
PyStatus_Exit^⚠
PyStatus_IsError^⚠
PyStatus_IsExit^⚠
PyStatus_NoMemory^⚠
PyStatus_Ok^⚠
PyStructSequence_GET_ITEM^⚠
PyStructSequence_GetItem^⚠
PyStructSequence_InitType^⚠
PyStructSequence_InitType2^⚠
PyStructSequence_New^⚠
PyStructSequence_NewType^⚠
PyStructSequence_SET_ITEM^⚠
PyStructSequence_SetItem^⚠
PySys_AddWarnOption^⚠
PySys_AddWarnOptionUnicode^⚠
PySys_AddXOption^⚠
PySys_FormatStderr^⚠
PySys_FormatStdout^⚠
PySys_GetObject^⚠
PySys_GetXOptions^⚠
PySys_HasWarnOptions^⚠
PySys_ResetWarnOptions^⚠
PySys_SetArgv^⚠
PySys_SetArgvEx^⚠
PySys_SetObject^⚠
PySys_SetPath^⚠
PySys_WriteStderr^⚠
PySys_WriteStdout^⚠
PyTZInfo_Check^⚠: Check if op is a PyDateTimeAPI.TZInfoType or subtype.
PyTZInfo_CheckExact^⚠: Check if op’s type is exactly PyDateTimeAPI.TZInfoType.
PyThreadState_Clear^⚠
PyThreadState_Delete^⚠
PyThreadState_DeleteCurrent^⚠
PyThreadState_GET^⚠
PyThreadState_Get^⚠
PyThreadState_GetDict^⚠
PyThreadState_New^⚠
PyThreadState_Next^⚠
PyThreadState_SetAsyncExc^⚠
PyThreadState_Swap^⚠
PyTimeZone_FromOffset^⚠
PyTimeZone_FromOffsetAndName^⚠
PyTime_Check^⚠: Check if op is a PyDateTimeAPI.TimeType or subtype.
PyTime_CheckExact^⚠: Check if op’s type is exactly PyDateTimeAPI.TimeType.
PyTraceBack_Check^⚠
PyTraceBack_Here^⚠
PyTraceBack_Print^⚠
PyTuple_Check^⚠
PyTuple_CheckExact^⚠
PyTuple_ClearFreeList^⚠
PyTuple_GET_ITEM^⚠
PyTuple_GET_SIZE^⚠: Macro, trading safety for speed
PyTuple_GetItem^⚠
PyTuple_GetSlice^⚠
PyTuple_New^⚠
PyTuple_Pack^⚠
PyTuple_SET_ITEM^⚠: Macro, only to be used to fill in brand new tuples
PyTuple_SetItem^⚠
PyTuple_Size^⚠
PyType_Check^⚠
PyType_CheckExact^⚠
PyType_ClearCache^⚠
PyType_FastSubclass^⚠
PyType_FromSpec^⚠
PyType_FromSpecWithBases^⚠
PyType_GenericAlloc^⚠
PyType_GenericNew^⚠
PyType_GetFlags^⚠
PyType_GetSlot^⚠
PyType_HasFeature^⚠
PyType_IS_GC^⚠
PyType_IsSubtype^⚠
PyType_Modified^⚠
PyType_Ready^⚠
PyType_SUPPORTS_WEAKREFS^⚠
PyUnicodeDecodeError_Create^⚠
PyUnicodeDecodeError_GetEncoding^⚠
PyUnicodeDecodeError_GetEnd^⚠
PyUnicodeDecodeError_GetObject^⚠
PyUnicodeDecodeError_GetReason^⚠
PyUnicodeDecodeError_GetStart^⚠
PyUnicodeDecodeError_SetEnd^⚠
PyUnicodeDecodeError_SetReason^⚠
PyUnicodeDecodeError_SetStart^⚠
PyUnicodeEncodeError_GetEncoding^⚠
PyUnicodeEncodeError_GetEnd^⚠
PyUnicodeEncodeError_GetObject^⚠
PyUnicodeEncodeError_GetReason^⚠
PyUnicodeEncodeError_GetStart^⚠
PyUnicodeEncodeError_SetEnd^⚠
PyUnicodeEncodeError_SetReason^⚠
PyUnicodeEncodeError_SetStart^⚠
PyUnicodeTranslateError_GetEnd^⚠
PyUnicodeTranslateError_GetObject^⚠
PyUnicodeTranslateError_GetReason^⚠
PyUnicodeTranslateError_GetStart^⚠
PyUnicodeTranslateError_SetEnd^⚠
PyUnicodeTranslateError_SetReason^⚠
PyUnicodeTranslateError_SetStart^⚠
PyUnicode_1BYTE_DATA^⚠
PyUnicode_2BYTE_DATA^⚠
PyUnicode_4BYTE_DATA^⚠
PyUnicode_Append^⚠
PyUnicode_AppendAndDel^⚠
PyUnicode_AsASCIIString^⚠
PyUnicode_AsCharmapString^⚠
PyUnicode_AsDecodedObject^⚠
PyUnicode_AsDecodedUnicode^⚠
PyUnicode_AsEncodedObject^⚠
PyUnicode_AsEncodedString^⚠
PyUnicode_AsEncodedUnicode^⚠
PyUnicode_AsLatin1String^⚠
PyUnicode_AsRawUnicodeEscapeString^⚠
PyUnicode_AsUCS4^⚠
PyUnicode_AsUCS4Copy^⚠
PyUnicode_AsUTF8^⚠
PyUnicode_AsUTF8AndSize^⚠
PyUnicode_AsUTF8String^⚠
PyUnicode_AsUTF16String^⚠
PyUnicode_AsUTF32String^⚠
PyUnicode_AsUnicode^⚠Deprecated
PyUnicode_AsUnicodeAndSize^⚠Deprecated
PyUnicode_AsUnicodeEscapeString^⚠
PyUnicode_AsWideChar^⚠
PyUnicode_AsWideCharString^⚠
PyUnicode_BuildEncodingMap^⚠
PyUnicode_Check^⚠
PyUnicode_CheckExact^⚠
PyUnicode_ClearFreeList^⚠
PyUnicode_Compare^⚠
PyUnicode_CompareWithASCIIString^⚠
PyUnicode_Concat^⚠
PyUnicode_Contains^⚠
PyUnicode_CopyCharacters^⚠
PyUnicode_Count^⚠
PyUnicode_DATA^⚠
PyUnicode_Decode^⚠
PyUnicode_DecodeASCII^⚠
PyUnicode_DecodeCharmap^⚠
PyUnicode_DecodeFSDefault^⚠
PyUnicode_DecodeFSDefaultAndSize^⚠
PyUnicode_DecodeLatin1^⚠
PyUnicode_DecodeLocale^⚠
PyUnicode_DecodeLocaleAndSize^⚠
PyUnicode_DecodeRawUnicodeEscape^⚠
PyUnicode_DecodeUTF7^⚠
PyUnicode_DecodeUTF8^⚠
PyUnicode_DecodeUTF7Stateful^⚠
PyUnicode_DecodeUTF8Stateful^⚠
PyUnicode_DecodeUTF16^⚠
PyUnicode_DecodeUTF32^⚠
PyUnicode_DecodeUTF16Stateful^⚠
PyUnicode_DecodeUTF32Stateful^⚠
PyUnicode_DecodeUnicodeEscape^⚠
PyUnicode_Encode^⚠
PyUnicode_EncodeASCII^⚠
PyUnicode_EncodeCharmap^⚠
PyUnicode_EncodeDecimal^⚠
PyUnicode_EncodeFSDefault^⚠
PyUnicode_EncodeLatin1^⚠
PyUnicode_EncodeLocale^⚠
PyUnicode_EncodeRawUnicodeEscape^⚠
PyUnicode_EncodeUTF7^⚠
PyUnicode_EncodeUTF8^⚠
PyUnicode_EncodeUTF16^⚠
PyUnicode_EncodeUTF32^⚠
PyUnicode_EncodeUnicodeEscape^⚠
PyUnicode_FSConverter^⚠
PyUnicode_FSDecoder^⚠
PyUnicode_Fill^⚠
PyUnicode_Find^⚠
PyUnicode_FindChar^⚠
PyUnicode_Format^⚠
PyUnicode_FromEncodedObject^⚠
PyUnicode_FromFormat^⚠
PyUnicode_FromKindAndData^⚠
PyUnicode_FromObject^⚠
PyUnicode_FromOrdinal^⚠
PyUnicode_FromString^⚠
PyUnicode_FromStringAndSize^⚠
PyUnicode_FromUnicode^⚠Deprecated
PyUnicode_FromWideChar^⚠
PyUnicode_GET_LENGTH^⚠
PyUnicode_GetDefaultEncoding^⚠
PyUnicode_GetLength^⚠
PyUnicode_GetSize^⚠Deprecated
PyUnicode_IS_ASCII^⚠
PyUnicode_IS_COMPACT^⚠
PyUnicode_IS_COMPACT_ASCII^⚠
PyUnicode_IS_READY^⚠
PyUnicode_InternFromString^⚠
PyUnicode_InternImmortal^⚠
PyUnicode_InternInPlace^⚠
PyUnicode_IsIdentifier^⚠
PyUnicode_Join^⚠
PyUnicode_KIND^⚠
PyUnicode_New^⚠
PyUnicode_Partition^⚠
PyUnicode_READY^⚠
PyUnicode_RPartition^⚠
PyUnicode_RSplit^⚠
PyUnicode_ReadChar^⚠
PyUnicode_Replace^⚠
PyUnicode_Resize^⚠
PyUnicode_RichCompare^⚠
PyUnicode_Split^⚠
PyUnicode_Splitlines^⚠
PyUnicode_Substring^⚠
PyUnicode_Tailmatch^⚠
PyUnicode_TransformDecimalToASCII^⚠
PyUnicode_Translate^⚠
PyUnicode_TranslateCharmap^⚠
PyUnicode_WriteChar^⚠
PyVectorcall_Call^⚠
PyVectorcall_Function^⚠
PyVectorcall_NARGS^⚠
PyWeakref_Check^⚠
PyWeakref_CheckProxy^⚠
PyWeakref_CheckRef^⚠
PyWeakref_CheckRefExact^⚠
PyWeakref_GetObject^⚠
PyWeakref_NewProxy^⚠
PyWeakref_NewRef^⚠
PyWideStringList_Append^⚠
PyWideStringList_Insert^⚠
PyWrapper_New^⚠
Py_AddPendingCall^⚠
Py_AtExit^⚠
Py_BuildValue^⚠
Py_BytesMain^⚠
Py_CLEAR^⚠
Py_CompileString^⚠
Py_CompileStringExFlags^⚠
Py_CompileStringFlags^⚠
Py_CompileStringObject^⚠
Py_DECREF^⚠
Py_DecRef^⚠
Py_DecodeLocale^⚠
Py_Ellipsis^⚠
Py_EncodeLocale^⚠
Py_EndInterpreter^⚠
Py_Exit^⚠
Py_ExitStatusException^⚠
Py_False^⚠
Py_FatalError^⚠
Py_Finalize^⚠
Py_FinalizeEx^⚠
Py_GETENV^⚠
Py_GetArgcArgv^⚠
Py_GetBuildInfo^⚠
Py_GetCompiler^⚠
Py_GetCopyright^⚠
Py_GetExecPrefix^⚠
Py_GetPath^⚠
Py_GetPlatform^⚠
Py_GetPrefix^⚠
Py_GetProgramFullPath^⚠
Py_GetProgramName^⚠
Py_GetPythonHome^⚠
Py_GetRecursionLimit^⚠
Py_GetVersion^⚠
Py_INCREF^⚠
Py_IS_TYPE^⚠
Py_IncRef^⚠
Py_Initialize^⚠
Py_InitializeEx^⚠
Py_InitializeFromConfig^⚠
Py_Is^⚠
Py_IsFalse^⚠
Py_IsInitialized^⚠
Py_IsNone^⚠
Py_IsTrue^⚠
Py_Main^⚠
Py_MakePendingCalls^⚠
Py_NewInterpreter^⚠
Py_None^⚠
Py_NotImplemented^⚠
Py_PreInitialize^⚠
Py_PreInitializeFromArgs^⚠
Py_PreInitializeFromBytesArgs^⚠
Py_REFCNT^⚠
Py_ReprEnter^⚠
Py_ReprLeave^⚠
Py_RunMain^⚠
Py_SIZE^⚠
Py_SetPath^⚠
Py_SetProgramName^⚠
Py_SetPythonHome^⚠
Py_SetRecursionLimit^⚠
Py_SymtableString^⚠
Py_SymtableStringObject^⚠
Py_TYPE^⚠
Py_True^⚠
Py_XDECREF^⚠
Py_XINCREF^⚠
_PyBytes_Resize^⚠
_PyCode_GetExtra^⚠
_PyCode_SetExtra^⚠
_PyDict_Contains^⚠
_PyDict_NewPresized^⚠
_PyDict_Next^⚠
_PyDict_SetItem_KnownHash^⚠
_PyErr_BadInternalCall^⚠
_PyEval_EvalFrameDefault^⚠
_PyEval_RequestCodeExtraIndex^⚠
_PyFloat_CAST^⚠
_PyImport_AcquireLock^⚠
_PyImport_FindBuiltin^⚠
_PyImport_FindExtensionObject^⚠
_PyImport_FixupBuiltin^⚠
_PyImport_FixupExtensionObject^⚠
_PyImport_IsInitialized^⚠
_PyImport_ReleaseLock^⚠
_PyImport_SetModule^⚠
_PyImport_SetModuleString^⚠
_PyLong_AsByteArray^⚠
_PyLong_FromByteArray^⚠
_PyLong_NumBits^⚠
_PyObject_CallFunction_SizeT^⚠
_PyObject_CallMethod_SizeT^⚠
_PyObject_CallNoArg^⚠
_PyObject_FastCall^⚠
_PyObject_FastCallTstate^⚠
_PyObject_GC_Calloc^⚠
_PyObject_GC_Malloc^⚠
_PyObject_GC_New^⚠
_PyObject_GC_NewVar^⚠
_PyObject_GC_Resize^⚠
_PyObject_MakeTpCall^⚠
_PyObject_New^⚠
_PyObject_NewVar^⚠
_PyObject_VectorcallTstate^⚠
_PyRun_AnyFileObject^⚠
_PyRun_InteractiveLoopObject^⚠
_PyRun_SimpleFileObject^⚠
_PySequence_IterSearch^⚠
_PySet_NextEntry^⚠
_PyStack_AsDict^⚠
_PyUnicode_COMPACT_DATA^⚠
_PyUnicode_CheckConsistency^⚠
_PyUnicode_NONCOMPACT_DATA^⚠
_PyUnicode_Ready^⚠
_Py_CheckFunctionResult^⚠
_Py_GetAllocatedBlocks^⚠
_Py_HashBytes^⚠
_Py_InitializeMain^⚠
_Py_IsCoreInitialized^⚠

Type Aliases§

Unions§

PyMethodDefPointer: Function types used to implement Python callables.
PyUnicodeObjectData

Crate pyo3_ffiCopy item path