# Crate pyo3_ffi

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

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

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
- structmember Deprecated

## Macros§

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

## Structs§

- PyASCIIObject
- PyAsyncMethods
- PyBaseExceptionObject
- PyBufferProcs
- PyByteArrayObject
- PyBytesObject
- PyCFunctionObject
- PyCMethodObject
- 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
- PyDictValues
- PyFloatObject
- PyFrameObject
- PyFunctionObject
- PyFutureFeatures
- PyGenObject
- PyGetSetDef
  Represents the PyGetSetDef structure.
- PyGetSetDescrObject
- PyHash_FuncDef
- PyHeapTypeObject
- PyImportErrorObject
- PyInterpreterConfig
- 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
- PyTupleObject
- PyTypeObject
- PyType_Slot
- PyType_Spec
- PyUnicodeErrorObject
- PyUnicodeObject
- PyVarObject
- PyWideStringList
- PyWrapperDescrObject
- Py_buffer
- Py_complex
- _PyCoCached
- _PyCoLineInstrumentationData
- _PyCoMonitoringData
- _PyCompilerSrcLocation
- _PyDateTime_BaseDateTime
  Structure representing a `datetime.datetime` without a `tzinfo` member.
- _PyDateTime_BaseTime
  Structure representing a `datetime.time` without a `tzinfo` member.
- _PyErr_StackItem
- _PyInterpreterFrame
- _PyWeakReference
- _Py_GlobalMonitors
- _Py_LocalMonitors
- _frozen
- _inittab
- setentry
- wrapperbase

## Enums§

- PyGILState_STATE
- PyMemAllocatorDomain
- PySendResult
- _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_METHOD
- 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
- PyInterpreterConfig_DEFAULT_GIL
- PyInterpreterConfig_OWN_GIL
- PyInterpreterConfig_SHARED_GIL
- 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
- PyWrapperFlag_KEYWORDS
- Py_AUDIT_READ
- 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_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED
- Py_MOD_MULTIPLE_INTERPRETERS_SUPPORTED
- Py_MOD_PER_INTERPRETER_GIL_SUPPORTED
- 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_DISALLOW_INSTANTIATION
- 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_IMMUTABLETYPE
- Py_TPFLAGS_IS_ABSTRACT
- Py_TPFLAGS_ITEMS_AT_END
- Py_TPFLAGS_LIST_SUBCLASS
- Py_TPFLAGS_LONG_SUBCLASS
- Py_TPFLAGS_MANAGED_DICT
- Py_TPFLAGS_MANAGED_WEAKREF
- Py_TPFLAGS_MAPPING
- 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_SEQUENCE
- 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_fstring_input
- Py_func_type_input
- Py_mod_create
- Py_mod_exec
- Py_mod_multiple_interpreters
- 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_IMMORTAL_STATIC
- SSTATE_INTERNED_MORTAL
- SSTATE_NOT_INTERNED
- _PY_MONITORING_EVENTS
- _PY_MONITORING_LOCAL_EVENTS
- _PY_MONITORING_UNGROUPED_EVENTS
- _PyHASH_MULTIPLIER
- _PyInterpreterConfig_INIT
- _PyInterpreterConfig_LEGACY_INIT
- _Py_T_NONE Deprecated
- _Py_T_OBJECT Deprecated
- _Py_WRITE_RESTRICTED Deprecated

## Statics§

- PyAsyncGen_Type⚠
- PyBaseObject_Type⚠
  built-in ‘object’
- PyBool_Type⚠
- PyByteArrayIter_Type⚠
- PyByteArray_Type⚠
- PyBytesIter_Type⚠
- PyBytes_Type⚠
- PyCFunction_Type⚠
- PyCMethod_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_BaseExceptionGroup⚠
- PyExc_BlockingIOError⚠
- PyExc_BrokenPipeError⚠
- PyExc_BufferError⚠
- PyExc_BytesWarning⚠
- PyExc_ChildProcessError⚠
- PyExc_ConnectionAbortedError⚠
- PyExc_ConnectionError⚠
- PyExc_ConnectionRefusedError⚠
- PyExc_ConnectionResetError⚠
- PyExc_DeprecationWarning⚠
- PyExc_EOFError⚠
- PyExc_EncodingWarning⚠
- 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_GenericAliasType⚠
- 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⚠
- _PyImport_FrozenBootstrap⚠
- _PyImport_FrozenStdlib⚠
- _PyImport_FrozenTest⚠
- _PyManagedBuffer_Type⚠
- _PyMethodWrapper_Type⚠
- _PySet_Dummy⚠
- _PyWeakref_CallableProxyType⚠
- _PyWeakref_ProxyType⚠
- _PyWeakref_RefType⚠

## Functions§

- 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⚠Deprecated
- PyCFunction_Check⚠
- PyCFunction_CheckExact⚠
- PyCFunction_GET_CLASS⚠
- PyCFunction_GET_FLAGS⚠
- PyCFunction_GET_FUNCTION⚠
- PyCFunction_GET_SELF⚠
- PyCFunction_GetFlags⚠
- PyCFunction_GetFunction⚠
- PyCFunction_GetSelf⚠
- PyCFunction_New⚠
- PyCFunction_NewEx⚠
- PyCMethod_Check⚠
- PyCMethod_CheckExact⚠
- PyCMethod_New⚠
- 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_Unregister⚠
- 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_DisplayException⚠
- PyErr_ExceptionMatches⚠
- PyErr_Fetch⚠Deprecated
- PyErr_Format⚠
- PyErr_GetExcInfo⚠
- PyErr_GetRaisedException⚠
- PyErr_GivenExceptionMatches⚠
- PyErr_NewException⚠
- PyErr_NewExceptionWithDoc⚠
- PyErr_NoMemory⚠
- PyErr_NormalizeException⚠Deprecated
- PyErr_Occurred⚠
- PyErr_Print⚠
- PyErr_PrintEx⚠
- PyErr_ProgramText⚠
- PyErr_ResourceWarning⚠
- PyErr_Restore⚠Deprecated
- PyErr_SetExcInfo⚠
- PyErr_SetFromErrno⚠
- PyErr_SetFromErrnoWithFilename⚠
- PyErr_SetFromErrnoWithFilenameObject⚠
- PyErr_SetFromErrnoWithFilenameObjects⚠
- PyErr_SetImportError⚠
- PyErr_SetImportErrorSubclass⚠
- PyErr_SetInterrupt⚠
- PyErr_SetInterruptEx⚠
- PyErr_SetNone⚠
- PyErr_SetObject⚠
- PyErr_SetRaisedException⚠
- PyErr_SetString⚠
- PyErr_SyntaxLocation⚠
- PyErr_SyntaxLocationEx⚠
- PyErr_WarnEx⚠
- PyErr_WarnExplicit⚠
- PyErr_WarnFormat⚠
- PyErr_WriteUnraisable⚠
- PyEval_AcquireLock⚠
- PyEval_AcquireThread⚠
- PyEval_CallFunction⚠Deprecated
- PyEval_CallMethod⚠Deprecated
- PyEval_CallObject⚠Deprecated
- PyEval_CallObjectWithKeywords⚠Deprecated
- PyEval_EvalCode⚠
- PyEval_EvalCodeEx⚠
- PyEval_EvalFrame⚠
- PyEval_EvalFrameEx⚠
- PyEval_GetBuiltins⚠
- PyEval_GetCallStats⚠
- PyEval_GetFrame⚠
- PyEval_GetFuncDesc⚠
- PyEval_GetFuncName⚠
- PyEval_GetGlobals⚠
- PyEval_GetLocals⚠
- PyEval_InitThreads⚠Deprecated
- PyEval_ReleaseLock⚠
- PyEval_ReleaseThread⚠
- PyEval_RestoreThread⚠
- PyEval_SaveThread⚠
- PyEval_SetProfile⚠
- PyEval_SetTrace⚠
- PyEval_ThreadsInitialized⚠Deprecated
- 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_BlockSetup⚠
- PyFrame_Check⚠
- PyFrame_FastToLocals⚠
- PyFrame_FastToLocalsWithError⚠
- PyFrame_GetBack⚠
- PyFrame_GetCode⚠
- 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⚠
- PyGC_Collect⚠
- PyGC_Disable⚠
- PyGC_Enable⚠
- PyGC_IsEnabled⚠
- PyGILState_Check⚠
- PyGILState_Ensure⚠
- PyGILState_GetThisThreadState⚠
- PyGILState_Release⚠
- PyGen_Check⚠
- PyGen_CheckExact⚠
- PyGen_New⚠
- PyHash_GetFuncDef⚠
- PyImport_AddModule⚠
- PyImport_AddModuleObject⚠
- PyImport_AppendInittab⚠
- 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_Get⚠
- PyInterpreterState_GetDict⚠
- PyInterpreterState_GetID⚠
- PyInterpreterState_Head⚠
- PyInterpreterState_Main⚠
- PyInterpreterState_New⚠
- PyInterpreterState_Next⚠
- PyInterpreterState_ThreadHead⚠
- PyIter_Check⚠
- PyIter_Next⚠
- PyIter_Send⚠
- 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_AddObjectRef⚠
- PyModule_AddStringConstant⚠
- PyModule_AddType⚠
- 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⚠
- 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_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_CallMethodNoArgs⚠
- PyObject_CallMethodObjArgs⚠
- PyObject_CallMethodOneArg⚠
- PyObject_CallNoArgs⚠
- 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_IsFinalized⚠
- PyObject_GC_IsTracked⚠
- 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_GetTypeData⚠
- PyObject_GetTypeDataSize⚠
- 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⚠
- PyObject_VectorcallMethod⚠
- 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_CheckExact⚠
- 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⚠Deprecated
- PySys_AddWarnOptionUnicode⚠Deprecated
- PySys_AddXOption⚠
- PySys_FormatStderr⚠
- PySys_FormatStdout⚠
- PySys_GetObject⚠
- PySys_GetXOptions⚠
- PySys_HasWarnOptions⚠Deprecated
- PySys_ResetWarnOptions⚠
- PySys_SetArgv⚠Deprecated
- PySys_SetArgvEx⚠Deprecated
- 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_GetFrame⚠
- 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_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_FromMetaclass⚠
- PyType_FromModuleAndSpec⚠
- PyType_FromSpec⚠
- PyType_FromSpecWithBases⚠
- PyType_GenericAlloc⚠
- PyType_GenericNew⚠
- PyType_GetDict⚠
- PyType_GetFlags⚠
- PyType_GetModule⚠
- PyType_GetModuleByDef⚠
- PyType_GetModuleState⚠
- PyType_GetName⚠
- PyType_GetQualName⚠
- 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_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_FromWideChar⚠
- PyUnicode_GET_LENGTH⚠
- PyUnicode_GetDefaultEncoding⚠
- PyUnicode_GetLength⚠
- PyUnicode_IS_ASCII⚠
- PyUnicode_IS_COMPACT⚠
- PyUnicode_IS_COMPACT_ASCII⚠
- PyUnicode_IS_READY⚠
- PyUnicode_InternFromString⚠
- 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_EnterRecursiveCall⚠
- Py_Exit⚠
- Py_ExitStatusException⚠
- Py_False⚠
- Py_FatalError⚠
- Py_Finalize⚠
- Py_FinalizeEx⚠
- Py_GETENV⚠
- Py_GenericAlias⚠
- 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_LeaveRecursiveCall⚠
- Py_Main⚠
- Py_MakePendingCalls⚠
- Py_NewInterpreter⚠
- Py_NewInterpreterFromConfig⚠
- Py_NewRef⚠
- Py_None⚠
- Py_NotImplemented⚠
- Py_PreInitialize⚠
- Py_PreInitializeFromArgs⚠
- Py_PreInitializeFromBytesArgs⚠
- Py_REFCNT⚠
- Py_ReprEnter⚠
- Py_ReprLeave⚠
- Py_RunMain⚠
- Py_SIZE⚠
- Py_SetPath⚠Deprecated
- Py_SetProgramName⚠Deprecated
- Py_SetPythonHome⚠Deprecated
- Py_SetRecursionLimit⚠
- Py_TYPE⚠
- Py_True⚠
- Py_XDECREF⚠
- Py_XINCREF⚠
- Py_XNewRef⚠
- _PyBytes_Resize⚠
- _PyCode_GetExtra⚠
- _PyCode_SetExtra⚠
- _PyDict_Contains_KnownHash⚠
- _PyDict_NewPresized⚠
- _PyDict_Next⚠
- _PyDict_SetItem_KnownHash⚠
- _PyErr_BadInternalCall⚠
- _PyEval_EvalFrameDefault⚠
- _PyEval_RequestCodeExtraIndex⚠
- _PyFloat_CAST⚠
- _PyImport_AcquireLock⚠
- _PyImport_FixupBuiltin⚠
- _PyImport_FixupExtensionObject⚠
- _PyImport_IsInitialized⚠
- _PyImport_ReleaseLock⚠
- _PyImport_SetModule⚠
- _PyImport_SetModuleString⚠
- _PyInterpreterState_GetEvalFrameFunc⚠
  Get the frame evaluation function.
- _PyInterpreterState_SetEvalFrameFunc⚠
  Set the frame evaluation function.
- _PyLong_AsByteArray⚠
- _PyLong_FromByteArray⚠
- _PyLong_NumBits⚠
- _PyObject_CallFunction_SizeT⚠
- _PyObject_CallMethod_SizeT⚠
- _PyObject_CallNoArg⚠
- _PyObject_FastCall⚠
- _PyObject_FastCallTstate⚠
- _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_HashBytes⚠
- _Py_InitializeMain⚠
- _Py_IsCoreInitialized⚠

## Type Aliases§

- PY_INT32_T
- PY_INT64_T
- PY_UINT32_T
- PY_UINT64_T
- PyCFunction
- PyCFunctionFast
- PyCFunctionFastWithKeywords
- PyCFunctionWithKeywords
- PyCMethod
- PyCapsule_Destructor
- PyStructSequence
- Py_UCS1
- Py_UCS2
- Py_UCS4
- Py_UNICODE
- Py_hash_t
- Py_intptr_t
- Py_ssize_t
- Py_tracefunc
- Py_uhash_t
- Py_uintptr_t
- _PyCFunctionFast Deprecated
- _PyCFunctionFastWithKeywords Deprecated
- _PyFrameEvalFunction
- allocfunc
- binaryfunc
- descrgetfunc
- descrsetfunc
- destructor
- freefunc
- getattrfunc
- getattrofunc
- getbufferproc
- getiterfunc
- getter
- hashfunc
- initproc
- inquiry
- iternextfunc
- lenfunc
- newfunc
- objobjargproc
- objobjproc
- printfunc
- releasebufferproc
- reprfunc
- richcmpfunc
- sendfunc
- setattrfunc
- setattrofunc
- setter
- ssizeargfunc
- ssizeobjargproc
- ssizessizeargfunc
- ssizessizeobjargproc
- ternaryfunc
- traverseproc
- unaryfunc
- vectorcallfunc
- visitproc
- wrapperfunc
- wrapperfunc_kwds

## Unions§

- PyMethodDefPointer
  Function types used to implement Python callables.
- PyObjectObRefcnt
  This union is anonymous in CPython, so the name was given by PyO3 because Rust unions need a name.
- PyUnicodeObjectData