Struct pyo3::types::PyCapsule

#[repr(transparent)]
pub struct PyCapsule(_);

Represents a Python Capsule as described in Capsules:

This subtype of PyObject represents an opaque value, useful for C extension modules who need to pass an opaque value (as a void* pointer) through Python code to other C code. It is often used to make a C function pointer defined in one module available to other modules, so the regular import mechanism can be used to access C APIs defined in dynamically loaded modules.

Example

use pyo3::{prelude::*, types::PyCapsule};
use std::ffi::CString;

#[repr(C)]
struct Foo {
    pub val: u32,
}

let r = Python::with_gil(|py| -> PyResult<()> {
    let foo = Foo { val: 123 };
    let name = CString::new("builtins.capsule").unwrap();

    let capsule = PyCapsule::new(py, foo, Some(name.clone()))?;

    let module = PyModule::import(py, "builtins")?;
    module.add("capsule", capsule)?;

    let cap: &Foo = unsafe { PyCapsule::import(py, name.as_ref())? };
    assert_eq!(cap.val, 123);
    Ok(())
});
assert!(r.is_ok());

Implementations

impl PyCapsule

pub fn new<T: 'static + Send + AssertNotZeroSized>( py: Python<'_>, value: T, name: Option<CString> ) -> PyResult<&Self>

Constructs a new capsule whose contents are value, associated with name. name is the identifier for the capsule; if it is stored as an attribute of a module, the name should be in the format "modulename.attribute".

It is checked at compile time that the type T is not zero-sized. Rust function items need to be cast to a function pointer (fn(args) -> result) to be put into a capsule.

Example

use pyo3::{prelude::*, types::PyCapsule};
use std::ffi::CString;

Python::with_gil(|py| {
    let name = CString::new("foo").unwrap();
    let capsule = PyCapsule::new(py, 123_u32, Some(name)).unwrap();
    let val = unsafe { capsule.reference::<u32>() };
    assert_eq!(*val, 123);
});

However, attempting to construct a PyCapsule with a zero-sized type will not compile:

use pyo3::{prelude::*, types::PyCapsule};
use std::ffi::CString;

Python::with_gil(|py| {
    let capsule = PyCapsule::new(py, (), None).unwrap();  // Oops! `()` is zero sized!
});

pub fn new_with_destructor<T: 'static + Send + AssertNotZeroSized, F: FnOnce(T, *mut c_void) + Send>( py: Python<'_>, value: T, name: Option<CString>, destructor: F ) -> PyResult<&Self>

Constructs a new capsule whose contents are value, associated with name.

Also provides a destructor: when the PyCapsule is destroyed, it will be passed the original object, as well as a *mut c_void which will point to the capsule’s context, if any.

The destructor must be Send, because there is no guarantee which thread it will eventually be called from.

pub unsafe fn import<'py, T>(py: Python<'py>, name: &CStr) -> PyResult<&'py T>

Imports an existing capsule.

The name should match the path to the module attribute exactly in the form of "module.attribute", which should be the same as the name within the capsule.

Safety

It must be known that the capsule imported by name contains an item of type T.

pub fn set_context(&self, context: *mut c_void) -> PyResult<()>

Sets the context pointer in the capsule.

Returns an error if this capsule is not valid.

Notes

The context is treated much like the value of the capsule, but should likely act as a place to store any state management when using the capsule.

If you want to store a Rust value as the context, and drop it from the destructor, use Box::into_raw to convert it into a pointer, see the example.

Example

use std::sync::mpsc::{channel, Sender};
use libc::c_void;
use pyo3::{prelude::*, types::PyCapsule};

let (tx, rx) = channel::<String>();

fn destructor(val: u32, context: *mut c_void) {
    let ctx = unsafe { *Box::from_raw(context as *mut Sender<String>) };
    ctx.send("Destructor called!".to_string()).unwrap();
}

Python::with_gil(|py| {
    let capsule =
        PyCapsule::new_with_destructor(py, 123, None, destructor as fn(u32, *mut c_void))
            .unwrap();
    let context = Box::new(tx);  // `Sender<String>` is our context, box it up and ship it!
    capsule.set_context(Box::into_raw(context) as *mut c_void).unwrap();
    // This scope will end, causing our destructor to be called...
});

assert_eq!(rx.recv(), Ok("Destructor called!".to_string()));

pub fn context(&self) -> PyResult<*mut c_void>

Gets the current context stored in the capsule. If there is no context, the pointer will be null.

Returns an error if this capsule is not valid.

pub unsafe fn reference<T>(&self) -> &T

Obtains a reference to the value of this capsule.

Safety

It must be known that this capsule is valid and its pointer is to an item of type T.

pub fn pointer(&self) -> *mut c_void

Gets the raw c_void pointer to the value in this capsule.

Returns null if this capsule is not valid.

pub fn is_valid(&self) -> bool

Checks if this is a valid capsule.

Returns true if the stored pointer() is non-null.

pub fn name(&self) -> PyResult<Option<&CStr>>

Retrieves the name of this capsule, if set.

Returns an error if this capsule is not valid.

Methods from Deref<Target = PyAny>

pub fn is<T: AsPyPointer>(&self, other: &T) -> bool

Returns whether self and other point to the same object. To compare the equality of two objects (the == operator), use eq.

This is equivalent to the Python expression self is other.

pub fn hasattr<N>(&self, attr_name: N) -> PyResult<bool>where N: IntoPy<Py<PyString>>,

Determines whether this object has the given attribute.

This is equivalent to the Python expression hasattr(self, attr_name).

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern attr_name.

Example: intern!ing the attribute name

#[pyfunction]
fn has_version(sys: &PyModule) -> PyResult<bool> {
    sys.hasattr(intern!(sys.py(), "version"))
}

pub fn getattr<N>(&self, attr_name: N) -> PyResult<&PyAny>where N: IntoPy<Py<PyString>>,

Retrieves an attribute value.

This is equivalent to the Python expression self.attr_name.

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern attr_name.

Example: intern!ing the attribute name

#[pyfunction]
fn version(sys: &PyModule) -> PyResult<&PyAny> {
    sys.getattr(intern!(sys.py(), "version"))
}

pub fn setattr<N, V>(&self, attr_name: N, value: V) -> PyResult<()>where N: IntoPy<Py<PyString>>, V: ToPyObject,

Sets an attribute value.

This is equivalent to the Python expression self.attr_name = value.

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern name.

Example: intern!ing the attribute name

#[pyfunction]
fn set_answer(ob: &PyAny) -> PyResult<()> {
    ob.setattr(intern!(ob.py(), "answer"), 42)
}

pub fn delattr<N>(&self, attr_name: N) -> PyResult<()>where N: IntoPy<Py<PyString>>,

Deletes an attribute.

This is equivalent to the Python statement del self.attr_name.

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern attr_name.

pub fn compare<O>(&self, other: O) -> PyResult<Ordering>where O: ToPyObject,

Returns an Ordering between self and other.

This is equivalent to the following Python code:

if self == other:
    return Equal
elif a < b:
    return Less
elif a > b:
    return Greater
else:
    raise TypeError("PyAny::compare(): All comparisons returned false")

Examples

use pyo3::prelude::*;
use pyo3::types::PyFloat;
use std::cmp::Ordering;

Python::with_gil(|py| -> PyResult<()> {
    let a = PyFloat::new(py, 0_f64);
    let b = PyFloat::new(py, 42_f64);
    assert_eq!(a.compare(b)?, Ordering::Less);
    Ok(())
})?;

It will return PyErr for values that cannot be compared:

use pyo3::prelude::*;
use pyo3::types::{PyFloat, PyString};

Python::with_gil(|py| -> PyResult<()> {
    let a = PyFloat::new(py, 0_f64);
    let b = PyString::new(py, "zero");
    assert!(a.compare(b).is_err());
    Ok(())
})?;

pub fn rich_compare<O>( &self, other: O, compare_op: CompareOp ) -> PyResult<&PyAny>where O: ToPyObject,

Tests whether two Python objects obey a given CompareOp.

lt, le, eq, ne, gt and ge are the specialized versions of this function.

Depending on the value of compare_op, this is equivalent to one of the following Python expressions:

compare_op	Python expression
CompareOp::Eq	self == other
CompareOp::Ne	self != other
CompareOp::Lt	self < other
CompareOp::Le	self <= other
CompareOp::Gt	self > other
CompareOp::Ge	self >= other

Examples

use pyo3::class::basic::CompareOp;
use pyo3::prelude::*;
use pyo3::types::PyInt;

Python::with_gil(|py| -> PyResult<()> {
    let a: &PyInt = 0_u8.into_py(py).into_ref(py).downcast()?;
    let b: &PyInt = 42_u8.into_py(py).into_ref(py).downcast()?;
    assert!(a.rich_compare(b, CompareOp::Le)?.is_true()?);
    Ok(())
})?;

pub fn lt<O>(&self, other: O) -> PyResult<bool>where O: ToPyObject,

Tests whether this object is less than another.

This is equivalent to the Python expression self < other.

pub fn le<O>(&self, other: O) -> PyResult<bool>where O: ToPyObject,

Tests whether this object is less than or equal to another.

This is equivalent to the Python expression self <= other.

pub fn eq<O>(&self, other: O) -> PyResult<bool>where O: ToPyObject,

Tests whether this object is equal to another.

This is equivalent to the Python expression self == other.

pub fn ne<O>(&self, other: O) -> PyResult<bool>where O: ToPyObject,

Tests whether this object is not equal to another.

This is equivalent to the Python expression self != other.

pub fn gt<O>(&self, other: O) -> PyResult<bool>where O: ToPyObject,

Tests whether this object is greater than another.

This is equivalent to the Python expression self > other.

pub fn ge<O>(&self, other: O) -> PyResult<bool>where O: ToPyObject,

Tests whether this object is greater than or equal to another.

This is equivalent to the Python expression self >= other.

pub fn is_callable(&self) -> bool

Determines whether this object appears callable.

This is equivalent to Python’s callable() function.

Examples

use pyo3::prelude::*;

Python::with_gil(|py| -> PyResult<()> {
    let builtins = PyModule::import(py, "builtins")?;
    let print = builtins.getattr("print")?;
    assert!(print.is_callable());
    Ok(())
})?;

This is equivalent to the Python statement assert callable(print).

Note that unless an API needs to distinguish between callable and non-callable objects, there is no point in checking for callability. Instead, it is better to just do the call and handle potential exceptions.

pub fn call( &self, args: impl IntoPy<Py<PyTuple>>, kwargs: Option<&PyDict> ) -> PyResult<&PyAny>

Calls the object.

This is equivalent to the Python expression self(*args, **kwargs).

Examples

use pyo3::prelude::*;
use pyo3::types::PyDict;

const CODE: &str = r#"
def function(*args, **kwargs):
    assert args == ("hello",)
    assert kwargs == {"cruel": "world"}
    return "called with args and kwargs"
"#;

Python::with_gil(|py| {
    let module = PyModule::from_code(py, CODE, "", "")?;
    let fun = module.getattr("function")?;
    let args = ("hello",);
    let kwargs = PyDict::new(py);
    kwargs.set_item("cruel", "world")?;
    let result = fun.call(args, Some(kwargs))?;
    assert_eq!(result.extract::<&str>()?, "called with args and kwargs");
    Ok(())
})

pub fn call0(&self) -> PyResult<&PyAny>

Calls the object without arguments.

This is equivalent to the Python expression self().

Examples

use pyo3::prelude::*;

Python::with_gil(|py| -> PyResult<()> {
    let module = PyModule::import(py, "builtins")?;
    let help = module.getattr("help")?;
    help.call0()?;
    Ok(())
})?;

This is equivalent to the Python expression help().

pub fn call1(&self, args: impl IntoPy<Py<PyTuple>>) -> PyResult<&PyAny>

Calls the object with only positional arguments.

This is equivalent to the Python expression self(*args).

Examples

use pyo3::prelude::*;

const CODE: &str = r#"
def function(*args, **kwargs):
    assert args == ("hello",)
    assert kwargs == {}
    return "called with args"
"#;

Python::with_gil(|py| {
    let module = PyModule::from_code(py, CODE, "", "")?;
    let fun = module.getattr("function")?;
    let args = ("hello",);
    let result = fun.call1(args)?;
    assert_eq!(result.extract::<&str>()?, "called with args");
    Ok(())
})

pub fn call_method<N, A>( &self, name: N, args: A, kwargs: Option<&PyDict> ) -> PyResult<&PyAny>where N: IntoPy<Py<PyString>>, A: IntoPy<Py<PyTuple>>,

Calls a method on the object.

This is equivalent to the Python expression self.name(*args, **kwargs).

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern name.

Examples

use pyo3::prelude::*;
use pyo3::types::PyDict;

const CODE: &str = r#"
class A:
    def method(self, *args, **kwargs):
        assert args == ("hello",)
        assert kwargs == {"cruel": "world"}
        return "called with args and kwargs"
a = A()
"#;

Python::with_gil(|py| {
    let module = PyModule::from_code(py, CODE, "", "")?;
    let instance = module.getattr("a")?;
    let args = ("hello",);
    let kwargs = PyDict::new(py);
    kwargs.set_item("cruel", "world")?;
    let result = instance.call_method("method", args, Some(kwargs))?;
    assert_eq!(result.extract::<&str>()?, "called with args and kwargs");
    Ok(())
})

pub fn call_method0<N>(&self, name: N) -> PyResult<&PyAny>where N: IntoPy<Py<PyString>>,

Calls a method on the object without arguments.

This is equivalent to the Python expression self.name().

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern name.

Examples

use pyo3::prelude::*;

const CODE: &str = r#"
class A:
    def method(self, *args, **kwargs):
        assert args == ()
        assert kwargs == {}
        return "called with no arguments"
a = A()
"#;

Python::with_gil(|py| {
    let module = PyModule::from_code(py, CODE, "", "")?;
    let instance = module.getattr("a")?;
    let result = instance.call_method0("method")?;
    assert_eq!(result.extract::<&str>()?, "called with no arguments");
    Ok(())
})

pub fn call_method1<N, A>(&self, name: N, args: A) -> PyResult<&PyAny>where N: IntoPy<Py<PyString>>, A: IntoPy<Py<PyTuple>>,

Calls a method on the object with only positional arguments.

This is equivalent to the Python expression self.name(*args).

To avoid repeated temporary allocations of Python strings, the intern! macro can be used to intern name.

Examples

use pyo3::prelude::*;

const CODE: &str = r#"
class A:
    def method(self, *args, **kwargs):
        assert args == ("hello",)
        assert kwargs == {}
        return "called with args"
a = A()
"#;

Python::with_gil(|py| {
    let module = PyModule::from_code(py, CODE, "", "")?;
    let instance = module.getattr("a")?;
    let args = ("hello",);
    let result = instance.call_method1("method", args)?;
    assert_eq!(result.extract::<&str>()?, "called with args");
    Ok(())
})

pub fn is_true(&self) -> PyResult<bool>

Returns whether the object is considered to be true.

This is equivalent to the Python expression bool(self).

pub fn is_none(&self) -> bool

Returns whether the object is considered to be None.

This is equivalent to the Python expression self is None.

pub fn is_ellipsis(&self) -> bool

Returns whether the object is Ellipsis, e.g. ....

This is equivalent to the Python expression self is ....

pub fn is_empty(&self) -> PyResult<bool>

Returns true if the sequence or mapping has a length of 0.

This is equivalent to the Python expression len(self) == 0.

pub fn get_item<K>(&self, key: K) -> PyResult<&PyAny>where K: ToPyObject,

Gets an item from the collection.

This is equivalent to the Python expression self[key].

pub fn set_item<K, V>(&self, key: K, value: V) -> PyResult<()>where K: ToPyObject, V: ToPyObject,

Sets a collection item value.

This is equivalent to the Python expression self[key] = value.

pub fn del_item<K>(&self, key: K) -> PyResult<()>where K: ToPyObject,

Deletes an item from the collection.

This is equivalent to the Python expression del self[key].

pub fn iter(&self) -> PyResult<&PyIterator>

Takes an object and returns an iterator for it.

This is typically a new iterator but if the argument is an iterator, this returns itself.

pub fn get_type(&self) -> &PyType

Returns the Python type object for this object’s type.

pub fn get_type_ptr(&self) -> *mut PyTypeObject

Returns the Python type pointer for this object.

pub fn downcast<'p, T>(&'p self) -> Result<&'p T, PyDowncastError<'_>>where T: PyTryFrom<'p>,

Downcast this PyAny to a concrete Python type or pyclass.

Note that you can often avoid downcasting yourself by just specifying the desired type in function or method signatures. However, manual downcasting is sometimes necessary.

For extracting a Rust-only type, see PyAny::extract.

Example: Downcasting to a specific Python object

use pyo3::prelude::*;
use pyo3::types::{PyDict, PyList};

Python::with_gil(|py| {
    let dict = PyDict::new(py);
    assert!(dict.is_instance_of::<PyAny>());
    let any: &PyAny = dict.as_ref();

    assert!(any.downcast::<PyDict>().is_ok());
    assert!(any.downcast::<PyList>().is_err());
});

Example: Getting a reference to a pyclass

This is useful if you want to mutate a PyObject that might actually be a pyclass.

use pyo3::prelude::*;

#[pyclass]
struct Class {
    i: i32,
}

Python::with_gil(|py| {
    let class: &PyAny = Py::new(py, Class { i: 0 }).unwrap().into_ref(py);

    let class_cell: &PyCell<Class> = class.downcast()?;

    class_cell.borrow_mut().i += 1;

    // Alternatively you can get a `PyRefMut` directly
    let class_ref: PyRefMut<'_, Class> = class.extract()?;
    assert_eq!(class_ref.i, 1);
    Ok(())
})

pub fn downcast_exact<'p, T>(&'p self) -> Result<&'p T, PyDowncastError<'_>>where T: PyTryFrom<'p>,

Downcast this PyAny to a concrete Python type or pyclass (but not a subclass of it).

It is almost always better to use PyAny::downcast because it accounts for Python subtyping. Use this method only when you do not want to allow subtypes.

The advantage of this method over PyAny::downcast is that it is faster. The implementation of downcast_exact uses the equivalent of the Python expression type(self) is T, whereas downcast uses isinstance(self, T).

For extracting a Rust-only type, see PyAny::extract.

Example: Downcasting to a specific Python object but not a subtype

use pyo3::prelude::*;
use pyo3::types::{PyBool, PyLong};

Python::with_gil(|py| {
    let b = PyBool::new(py, true);
    assert!(b.is_instance_of::<PyBool>());
    let any: &PyAny = b.as_ref();

    // `bool` is a subtype of `int`, so `downcast` will accept a `bool` as an `int`
    // but `downcast_exact` will not.
    assert!(any.downcast::<PyLong>().is_ok());
    assert!(any.downcast_exact::<PyLong>().is_err());

    assert!(any.downcast_exact::<PyBool>().is_ok());
});

pub unsafe fn downcast_unchecked<'p, T>(&'p self) -> &'p Twhere T: PyTryFrom<'p>,

Converts this PyAny to a concrete Python type without checking validity.

Safety

Callers must ensure that the type is valid or risk type confusion.

pub fn extract<'a, D>(&'a self) -> PyResult<D>where D: FromPyObject<'a>,

Extracts some type from the Python object.

This is a wrapper function around FromPyObject::extract().

pub fn get_refcnt(&self) -> isize

Returns the reference count for the Python object.

pub fn repr(&self) -> PyResult<&PyString>

Computes the “repr” representation of self.

This is equivalent to the Python expression repr(self).

pub fn str(&self) -> PyResult<&PyString>

Computes the “str” representation of self.

This is equivalent to the Python expression str(self).

pub fn hash(&self) -> PyResult<isize>

Retrieves the hash code of self.

This is equivalent to the Python expression hash(self).

pub fn len(&self) -> PyResult<usize>

Returns the length of the sequence or mapping.

This is equivalent to the Python expression len(self).

pub fn dir(&self) -> &PyList

Returns the list of attributes of this object.

This is equivalent to the Python expression dir(self).

pub fn is_instance(&self, ty: &PyAny) -> PyResult<bool>

Checks whether this object is an instance of type ty.

This is equivalent to the Python expression isinstance(self, ty).

pub fn is_exact_instance(&self, ty: &PyAny) -> bool

Checks whether this object is an instance of exactly type ty (not a subclass).

This is equivalent to the Python expression type(self) is ty.

pub fn is_instance_of<T: PyTypeInfo>(&self) -> bool

Checks whether this object is an instance of type T.

This is equivalent to the Python expression isinstance(self, T), if the type T is known at compile time.

pub fn is_exact_instance_of<T: PyTypeInfo>(&self) -> bool

Checks whether this object is an instance of exactly type T.

This is equivalent to the Python expression type(self) is T, if the type T is known at compile time.

pub fn contains<V>(&self, value: V) -> PyResult<bool>where V: ToPyObject,

Determines if self contains value.

This is equivalent to the Python expression value in self.

pub fn py(&self) -> Python<'_>

Returns a GIL marker constrained to the lifetime of this type.

pub fn as_ptr(&self) -> *mut PyObject

Returns the raw FFI pointer represented by self.

Safety

Callers are responsible for ensuring that the pointer does not outlive self.

The reference is borrowed; callers should not decrease the reference count when they are finished with the pointer.

pub fn into_ptr(&self) -> *mut PyObject

Returns an owned raw FFI pointer represented by self.

Safety

The reference is owned; when finished the caller should either transfer ownership of the pointer or decrease the reference count (e.g. with pyo3::ffi::Py_DecRef).

pub fn py_super(&self) -> PyResult<&PySuper>

Return a proxy object that delegates method calls to a parent or sibling class of type.

This is equivalent to the Python expression super()

Trait Implementations

impl AsPyPointer for PyCapsule

fn as_ptr(&self) -> *mut PyObject

Gets the underlying FFI pointer, returns a borrowed pointer.

impl AsRef<PyAny> for PyCapsule

fn as_ref(&self) -> &PyAny

Converts this type into a shared reference of the (usually inferred) input type.

impl Debug for PyCapsule

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Deref for PyCapsule

type Target = PyAny

The resulting type after dereferencing.

fn deref(&self) -> &PyAny

Dereferences the value.

impl Display for PyCapsule

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'a> From<&'a PyCapsule> for &'a PyAny

fn from(ob: &'a PyCapsule) -> Self

Converts to this type from the input type.

impl From<&PyCapsule> for Py<PyCapsule>

fn from(other: &PyCapsule) -> Self

Converts to this type from the input type.

impl<'py> FromPyObject<'py> for &'py PyCapsule

fn extract(obj: &'py PyAny) -> PyResult<Self>

Extracts Self from the source PyObject.

fn type_input() -> TypeInfo

Extracts the type hint information for this type when it appears as an argument.

impl IntoPy<Py<PyCapsule>> for &PyCapsule

fn into_py(self, py: Python<'_>) -> Py<PyCapsule>

Performs the conversion.

fn type_output() -> TypeInfo

Extracts the type hint information for this type when it appears as a return value.

impl PyNativeType for PyCapsule

fn py(&self) -> Python<'_>

Returns a GIL marker constrained to the lifetime of this type.

unsafe fn unchecked_downcast(obj: &PyAny) -> &Self

Cast &PyAny to &Self without no type checking.

impl PyTypeInfo for PyCapsule

type AsRefTarget = PyCapsule

Utility type to make Py::as_ref work.

const NAME: &'static str = _

Class name.

const MODULE: Option<&'static str> = _

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn is_type_of(ptr: &PyAny) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn type_object(py: Python<'_>) -> &PyType

Returns the safe abstraction over the type object.

fn is_exact_type_of(object: &PyAny) -> bool

Checks if object is an instance of this type.

impl ToPyObject for PyCapsule

fn to_object(&self, py: Python<'_>) -> PyObject

Converts self into a Python object.