Struct pyo3::pyclass_init::PyClassInitializer [−][src]
pub struct PyClassInitializer<T: PyClass> { /* fields omitted */ }
Expand description
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
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>,
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
use pyo3::prelude::*;
#[pyclass(subclass)]
struct BaseClass {
#[pyo3(get)]
value: i32,
}
impl BaseClass {
fn new(value: i32) -> PyResult<Self> {
Ok(Self { 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 {}))
}
}
fn main() -> PyResult<()> {
Python::with_gil(|py| {
let m = PyModule::new(py, "example")?;
m.add_class::<SubClass>()?;
m.add_class::<BaseClass>()?;
let instance = m.getattr("SubClass")?.call1((92,))?;
// `SubClass` does not have a `value` attribute, but `BaseClass` does.
let n = instance.getattr("value")?.extract::<i32>()?;
assert_eq!(n, 92);
Ok(())
})
}
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>>,
impl<S, B> From<(S, B)> for PyClassInitializer<S> where
S: PyClass<BaseType = B>,
B: PyClass,
B::BaseType: PyClassBaseType<Initializer = PyNativeTypeInitializer<B::BaseType>>,
Performs the conversion.
impl<T> From<T> for PyClassInitializer<T> where
T: PyClass,
T::BaseType: PyClassBaseType<Initializer = PyNativeTypeInitializer<T::BaseType>>,
impl<T> From<T> for PyClassInitializer<T> where
T: PyClass,
T::BaseType: PyClassBaseType<Initializer = PyNativeTypeInitializer<T::BaseType>>,
Performs the conversion.
unsafe fn into_new_object(
self,
py: Python<'_>,
subtype: *mut PyTypeObject
) -> PyResult<*mut PyObject>
unsafe fn into_new_object(
self,
py: Python<'_>,
subtype: *mut PyTypeObject
) -> PyResult<*mut PyObject>
Safety Read more
This trait is private to implement; this method exists to make it impossible to implement outside the crate. Read more