#[repr(C)]
pub struct PyCell<T: PyClassImpl> { /* private fields */ }
Expand description

A container type for (mutably) accessing PyClass values

PyCell autodereferences to PyAny, so you can call PyAny’s methods on a PyCell<T>.

Examples

This example demonstrates getting a mutable reference of the contained PyClass.

use pyo3::prelude::*;

#[pyclass]
struct Number {
    inner: u32,
}

#[pymethods]
impl Number {
    fn increment(&mut self) {
        self.inner += 1;
    }
}

Python::with_gil(|py| {
    let n = PyCell::new(py, Number { inner: 0 })?;

    let n_mutable: &mut Number = &mut n.borrow_mut();
    n_mutable.increment();

    Ok(())
})

For more information on how, when and why (not) to use PyCell please see the module-level documentation.

Implementations

Makes a new PyCell on the Python heap and return the reference to it.

In cases where the value in the cell does not need to be accessed immediately after creation, consider Py::new as a more efficient alternative.

Immutably borrows the value T. This borrow lasts as long as the returned PyRef exists.

Panics

Panics if the value is currently mutably borrowed. For a non-panicking variant, use try_borrow.

Mutably borrows the value T. This borrow lasts as long as the returned PyRefMut exists.

Panics

Panics if the value is currently borrowed. For a non-panicking variant, use try_borrow_mut.

Immutably borrows the value T, returning an error if the value is currently mutably borrowed. This borrow lasts as long as the returned PyRef exists.

This is the non-panicking variant of borrow.

Examples
#[pyclass]
struct Class {}

Python::with_gil(|py| {
    let c = PyCell::new(py, Class {}).unwrap();
    {
        let m = c.borrow_mut();
        assert!(c.try_borrow().is_err());
    }

    {
        let m = c.borrow();
        assert!(c.try_borrow().is_ok());
    }
});

Mutably borrows the value T, returning an error if the value is currently borrowed. This borrow lasts as long as the returned PyRefMut exists.

This is the non-panicking variant of borrow_mut.

Examples
#[pyclass]
struct Class {}
Python::with_gil(|py| {
    let c = PyCell::new(py, Class {}).unwrap();
    {
        let m = c.borrow();
        assert!(c.try_borrow_mut().is_err());
    }

    assert!(c.try_borrow_mut().is_ok());
});

Immutably borrows the value T, returning an error if the value is currently mutably borrowed.

Safety

This method is unsafe because it does not return a PyRef, thus leaving the borrow flag untouched. Mutably borrowing the PyCell while the reference returned by this method is alive is undefined behaviour.

Examples
#[pyclass]
struct Class {}
Python::with_gil(|py| {
    let c = PyCell::new(py, Class {}).unwrap();

    {
        let m = c.borrow_mut();
        assert!(unsafe { c.try_borrow_unguarded() }.is_err());
    }

    {
        let m = c.borrow();
        assert!(unsafe { c.try_borrow_unguarded() }.is_ok());
    }
});

Replaces the wrapped value with a new one, returning the old value.

Panics

Panics if the value is currently borrowed.

Replaces the wrapped value with a new one computed from f, returning the old value.

Panics

Panics if the value is currently borrowed.

Swaps the wrapped value of self with the wrapped value of other.

Panics

Panics if the value in either PyCell is currently borrowed.

Methods from Deref<Target = PyAny>

Converts this PyAny to a concrete Python type.

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

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

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.

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.

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"))
}

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)
}

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.

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(())
})?;

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_opPython expression
CompareOp::Eqself == other
CompareOp::Neself != other
CompareOp::Ltself < other
CompareOp::Leself <= other
CompareOp::Gtself > other
CompareOp::Geself >= 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(())
})?;

Tests whether this object is less than another.

This is equivalent to the Python expression self < other.

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

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

Tests whether this object is equal to another.

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

Tests whether this object is not equal to another.

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

Tests whether this object is greater than another.

This is equivalent to the Python expression self > other.

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

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

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.

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(())
})

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().

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(())
})

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(())
})

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(())
})

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(())
})

Returns whether the object is considered to be true.

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

Returns whether the object is considered to be None.

This is equivalent to the Python expression self is None.

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

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

Gets an item from the collection.

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

Sets a collection item value.

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

Deletes an item from the collection.

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

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.

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

Returns the Python type pointer for this object.

Casts self to a concrete Python object type.

This can cast only to native Python types, not types implemented in Rust.

Extracts some type from the Python object.

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

Returns the reference count for the Python object.

Computes the “repr” representation of self.

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

Computes the “str” representation of self.

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

Retrieves the hash code of self.

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

Returns the length of the sequence or mapping.

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

Returns the list of attributes of this object.

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

Checks whether this object is an instance of type ty.

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

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.

Determines if self contains value.

This is equivalent to the Python expression value in self.

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

Trait Implementations

Returns the underlying FFI pointer as a borrowed pointer.

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

Formats the value using the given formatter. Read more

The resulting type after dereferencing.

Dereferences the value.

Converts to this type from the input type.

Extracts Self from the source PyObject.

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

Cast &PyAny to &Self without no type checking. Read more

Cast from a concrete Python object type to PyObject.

Cast from a concrete Python object type to PyObject. With exact type check.

Cast a PyAny to a specific type of PyObject. The caller must have already verified the reference is for this type. Read more

Converts self into a Python object.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Convert from an arbitrary PyObject. Read more

Convert from an arbitrary borrowed PyObject. Read more

Convert from an arbitrary PyObject or panic. Read more

Convert from an arbitrary PyObject or panic. Read more

Convert from an arbitrary PyObject. Read more

Convert from an arbitrary borrowed PyObject. Read more

Convert from an arbitrary borrowed PyObject. Read more

Convert from an arbitrary borrowed PyObject. Read more

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.