Failing to convert struct to equivalent pyobject

[shivam-880]

So I have been trying to mimic field based enums in rust in pyo3. Have come quite far with the implementation but I'm stuck trying to return the struct.

I do understand that the any struct that implements pyclass has into_py already implemented for it, as in the example I tried below:

#[pyclass]
#[derive(Clone)]
pub struct Point {
    #[pyo3(get)]
    x: usize,
    #[pyo3(get)]
    y: usize,
}

#[pymethods]
impl Point {
    #[new]
    fn new(x: usize, y: usize) -> Point {
        Point { x, y }
    }
}

#[pyfunction]
pub fn return_point(p: Point) -> Point {
    p
}

This works just fine:

p = return_point(Point(4, 5))
print(p.x, p.y)

However, with field enums I'm trying to implement I don't see into_py implemented by default. Here is the implementation:

#[derive(Debug)]
enum RProp {
    Str(String),
    Int(usize),
}

fn process_rprop(rprop: RProp) -> RProp {
    match rprop {
        RProp::Str(v) => RProp::Str(v),
        RProp::Int(v) => RProp::Int(v),
    }
}

#[pyclass(subclass)]
#[derive(Clone)]
pub struct Prop;

#[pymethods]
impl Prop {
    #[new]
    fn new() -> Self {
        Prop
    }

    fn delegate_call(&self) {}
}

#[pyclass(extends=Prop, subclass)]
#[derive(Clone)]
pub struct Str {
    value: String,
}

#[pymethods]
impl Str {
    #[new]
    fn new(value: String) -> (Self, Prop) {
        (Str { value }, Prop::new())
    }

    fn delegate_call(&self, py: Python<'_>) -> Str {
        process_rprop(self.clone().into()).into()
    }
}

impl From<Str> for RProp {
    fn from(v: Str) -> Self {
        RProp::Str(v.value)
    }
}

impl From<RProp> for Str {
    fn from(value: RProp) -> Self {
        match value {
            RProp::Str(value) => Str { value },
            RProp::Int(_) => panic!(),
        }
    }
}

#[pyfunction]
pub fn process_prop(s: &PyCell<Prop>) -> PyResult<&PyAny> {
    s.call_method0("delegate_call")
}

To explain a bit: I have RProp in Rust that is use in the rest of the library and Prop for the python user. I have implemented Str as subclass (See: #2959). I have From implemented for Str to RProp and vice versa. process_rprop takes and returns RProp. Similarly, process_prop takes and returns Prop which is what I intend to return to the user as say Str("pometry") and facing issues returning.

How I intend to use in python:

s = Str("pomtery")
print(process_prop(s))
# should print Str("pometry")

Line: #[pymethods] for Str complains:

the method `assert_into_py_result` exists for struct `Str`, but its trait bounds were not satisfied
the following trait bounds were not satisfied:
`Str: pyo3::IntoPy<Py<pyo3::PyAny>>`
which is required by `Str: IntoPyResult<Str>`rustc[Click for full compiler diagnostic](rust-analyzer-diagnostics-view:/diagnostic%20message%20%5B2%5D?2#file%3A%2F%2F%2FUsers%2Fshivamkapoor%2FPersonal%2Frepos%2Frust-field-enums-pyo3%2Fsrc%2Ffield_enums.rs)
field_enums.rs(32, 1): method `assert_into_py_result` not found for this struct
field_enums.rs(32, 1): doesn't satisfy `Str: IntoPyResult<Str>`
field_enums.rs(32, 1): doesn't satisfy `Str: pyo3::IntoPy<Py<pyo3::PyAny>>`
conversion.rs(244, 1): the following trait must be implemented

Not really sure how to fix it. Please suggest.

[davidhewitt]

Try this instead:

    fn delegate_call(&self, py: Python<'_>) -> PyResult<Py<Str>> {
        let s: Str = process_rprop(self.clone().into()).into();
        Py::new(py, (s, Prop::new()))
    }

The reason is that Str doesn't implement IntoPy, because it needs to have a Prop base class paired with it when built into a Python object.

[shivam-880]

Thanks for you answer @davidhewitt.

As a follow up question could you suggest how could I implement a bit more complex data structures, such as, Vec<Prop> and HashMap<String, Prop>:

fn process_rprops(rprops: Vec<RProp>) -> Vec<RProp> {
    rprops
}

fn process_rprops_hm(rprops: HashMap<String, RProp>) -> HashMap<String, RProp> {
    rprops
}

#[pyfunction]
pub fn process_props(s: Vec<Prop>) -> Vec<Prop> {
    let v1: Vec<RProp> = s.into_iter().map(|prop| prop.into()).collect::<Vec<_>>();
    let v2 = process_rprops(v1);
    let v3: Vec<Prop> = v2.into_iter().map(|rprop| rprop.into()).collect::<Vec<_>>();
    v3
}

#[pyfunction]
pub fn process_props_hm(s: HashMap<String, Prop>) -> HashMap<String, Prop> {
    
}

This clearly won't work because we can't convert Int and Str into RProp:: Int and RProp::Str polymorphically in Rust. This relationship is strictly pythonic!

[davidhewitt]

It's not entirely clear to me what you're wanting here, does using Py<Prop> work for you instead? That way you can lean on the Python polymorphism.

Note that #417, which would solve cases like this, is still unimplemented, just needs design input, so any experience you have here may be valuable for us to take onboard in PyO3's core.