Struct pyo3::pyclass_init::PyClassInitializer

pub struct PyClassInitializer<T: PyClass> { /* fields omitted */ }

Initializer for our #[pyclass] system.

You can use this type to initalize complicatedly nested #[pyclass].

Examples

#[pyclass(subclass)]
struct BaseClass {
    #[pyo3(get)]
    basename: &'static str,
}
#[pyclass(extends=BaseClass, subclass)]
struct SubClass {
    #[pyo3(get)]
    subname: &'static str,
}
#[pyclass(extends=SubClass)]
struct SubSubClass {
    #[pyo3(get)]
    subsubname: &'static str,
}

#[pymethods]
impl SubSubClass {
    #[new]
    fn new() -> PyClassInitializer<Self> {
        PyClassInitializer::from(BaseClass { basename: "base" })
            .add_subclass(SubClass { subname: "sub" })
            .add_subclass(SubSubClass { subsubname: "subsub" })
    }
}
Python::with_gil(|py| {
    let typeobj = py.get_type::<SubSubClass>();
    let sub_sub_class = typeobj.call((), None).unwrap();
    py_run!(
        py,
        sub_sub_class,
        r#"
 assert sub_sub_class.basename == 'base'
 assert sub_sub_class.subname == 'sub'
 assert sub_sub_class.subsubname == 'subsub'"#
    );
});

Implementations

impl<T: PyClass> PyClassInitializer<T>

pub fn new(
    init: T,
    super_init: <T::BaseType as PyClassBaseType>::Initializer
) -> Self

Constructs a new initializer from value T and base class’ initializer.

It is recommended to use add_subclass instead of this method for most usage.

pub fn add_subclass<S>(self, subclass_value: S) -> PyClassInitializer<S> where
    S: PyClass<BaseType = T>,
    S::BaseType: PyClassBaseType<Initializer = Self>, 

Constructs a new initializer from an initializer for the base class.

Examples

#[pyclass]
struct BaseClass {
    value: u32,
}

impl BaseClass {
    fn new(value: i32) -> PyResult<Self> {
        Ok(Self {
            value: std::convert::TryFrom::try_from(value)?,
        })
    }
}
#[pyclass(extends=BaseClass)]
struct SubClass {}

#[pymethods]
impl SubClass {
    #[new]
    fn new(value: i32) -> PyResult<PyClassInitializer<Self>> {
        let base_init = PyClassInitializer::from(BaseClass::new(value)?);
        Ok(base_init.add_subclass(SubClass {}))
    }
}

Trait Implementations

impl<S, B> From<(S, B)> for PyClassInitializer<S> where
    S: PyClass<BaseType = B>,
    B: PyClass,
    B::BaseType: PyClassBaseType<Initializer = PyNativeTypeInitializer<B::BaseType>>, 

fn from(sub_and_base: (S, B)) -> PyClassInitializer<S>

Performs the conversion.

impl<T> From<T> for PyClassInitializer<T> where
    T: PyClass,
    T::BaseType: PyClassBaseType<Initializer = PyNativeTypeInitializer<T::BaseType>>, 

fn from(value: T) -> PyClassInitializer<T>

Performs the conversion.

impl<T: PyClass> PyObjectInit<T> for PyClassInitializer<T>

unsafe fn into_new_object(
    self,
    py: Python<'_>,
    subtype: *mut PyTypeObject
) -> PyResult<*mut PyObject>

Safety

fn __private__(&self) -> PrivateMarker

This trait is private to implement; this method exists to make it impossible to implement outside the crate.