Convert Rust enum with many types to PyAny

[cisaacson]

I want to convert an enum we have, which is decorated with Serialize, Deserialize. The enum contains many types, some are structs, others are String or numeric types (there are over 20 of them).

I tried pythonize as it looks like just what I need. I used the example as-is and it says that acquire_gil is deprecated. I tried doing this using with_gil and it returns Py<PyAny>> and I just need a PyAny value. I tried various combinations but no luck.

Any advice on how to do this would be much appreciated.

Great library by the way, overall pyo3 has been very easy to use.

[adamreichold]

Having the exact code written down here would be helpful to better diagnose the issue, but the way to go from Py<PyAny> to &'py PyAny is via the as_ref method, but this will only work given a GIL token Python<'py>.

Generally speaking, PyAny is not used as a value, but either as a reference-counted pointer into the Python heap Py<PyAny> or as a reference bound to the lifetime of the GIL being taken &'py PyAny, c.f. the memory section of the guide. So I think the underlying issue here is understanding why you need a PyAny value in the first place.

[cisaacson]

@adamreichold Thanks for the quick response. After some manipulation, and returning Py<PyAny>> it actually works fine.

Here is the code:

#[pyfunction]
pub fn value_from_buffer(value_buf: Vec<u8>) -> PyResult<Py<PyAny>> {
    let rtip_value = match converters::value_from_buffer(&value_buf) {
        Ok(v) => v,
        Err(e) => {
            return Err(py_error::PyValueError::new_err(e));
        }
    };

    let py_value = Python::with_gil(|py| -> PyResult<Py<PyAny>> {
        let py_value = match pythonize(py, &rtip_value) {
            Ok(v) => v,
            Err(e) => {
                return Err(e.into());
            }
        };
        Ok(py_value)
    })?;

    Ok(py_value)
}

It is functional now, a buffer (Vec) in our API can return any number of types, I tried a few and they seem to work fine.

I was able to do the reverse as well, accepting a &PyAny and turning it back into a proper buffer.

Let me know if there is anything wrong with this approach. If it is fine, then we can close this out.

[adamreichold]

Let me know if there is anything wrong with this approach. If it is fine, then we can close this out.

I suspect that it could be code-golfed a bit, but the basic approach seems fine if you the Python side to able to inspect the value represented by the enum.

If you do not need that and just want Python code to pass around an otherwise opaque value, then it would most likely be simpler (and faster) to just wrap your enum inside a #[pyclass], e.g. assuming it is named RtipValue:

#[pyclass]
struct PyRtipValue {
  inner: RtipValue
}

This would allow you to return PyRtipValue from #[pyfunction] and take &/&mut PyRtipValue as arguments to #[pyfunction].

If you to need move out inner from the outer struct, you might need Option<RtipValue> to be able to .take() it, but maybe RtipValue itself already has a None-like variant which could be used instead.

[cisaacson]

Thanks @adamreichold, very helpful. We could do as you suggest, but we want just the individual value (so the 'String' or 'u64', etc.). The enum is just to make serialization work inside Rust. The suggestion will work in other places if needed, for this one I'll try and see if it fits.

Great library by the way, we were able to implement a lot very quickly.