How to migrate functions that take an Bound<'_, PyAny> and output PyObject to 0.23.0?

[evroon]

Let's say I have a function like below. It replaces the character a with b in a string, just as an example. If the input is a list instead of a string, it applies the function itself to every element in the list. For any other type, it's just an identity function, i.e. just return the input value.

#[pyfunction]
fn replace_a_with_b(py: Python, value: &Bound<'_, PyAny>) -> PyObject {
    if let Ok(string) = value.extract::<String>() {
        return string.replace('a', "b").to_object(py);
    }

    if let Ok(iter) = value.clone().downcast_into::<PyList>() {
        return iter
            .iter()
            .map(|x| replace_a_with_b(py, x.as_ref()).to_object(py))
            .collect::<Vec<PyObject>>()
            .to_object(py);
    }

    value.to_object(py)
}

How do I port this code to 0.23.3 and get rid of .to_object()? I read the migration guide but I still don't understand, since it mainly talks about implementing the IntoPyObject trait on structs, but here I don't have a custom struct, just &Bound<'_, PyAny> as parameter.

[evroon]

Ah okay I found some methods that weren't clear to me from the migration guide and now I have this:

#[pyfunction]
fn replace_a_with_b(py: Python, value: &Bound<'_, PyAny>) -> PyObject {
    if let Ok(string) = value.extract::<String>() {
        return string.replace('a', "b").into_pyobject(py).unwrap().into();
    }

    if let Ok(iter) = value.clone().downcast_into::<PyList>() {
        return iter
            .iter()
            .map(|x| {
                replace_a_with_b(py, x.as_ref())
                    .into_pyobject(py)
                    .unwrap()
                    .into()
            })
            .collect::<Vec<PyObject>>()
            .into_pyobject(py)
            .unwrap()
            .into();
    }

    value.into_bound_py_any(py).unwrap().into()
}

is that how you're supposed to do this? It seems a bit convoluted.

[LilyFoote]

I was able to refactor to this:

use pyo3::conversion::IntoPyObjectExt;
use pyo3::prelude::*;
use pyo3::types::PyList;

#[pyfunction]
fn replace_a_with_b<'py>(
    py: Python<'py>,
    value: &Bound<'py, PyAny>,
) -> PyResult<Bound<'py, PyAny>> {
    if let Ok(string) = value.extract::<String>() {
        return Ok(string.replace('a', "b").into_pyobject(py)?.into_any());
    }

    if let Ok(iter) = value.downcast::<PyList>() {
        return iter
            .iter()
            .map(|x| replace_a_with_b(py, x.as_ref()))
            .collect::<PyResult<Vec<Bound<'_, PyAny>>>>()?
            .into_pyobject(py);
    }

    value.into_bound_py_any(py)
}

There's two main changes I made here:

1. Change from PyObject to Bound<'py, PyAny> in the return value. This avoids needing quite so many .into() calls.
2. Wrap the return value in PyResult. This allows using the ? operator instead of unwrap().

Otherwise, I think this should be essentially equivalent. I've only got it to compile as a stand-alone piece of code, though; it's not tested in context, so I might have missed something.

I also agree that it can be quite difficult to keep all the different conversions between types clear in your mind - I had quite a few compiler errors before I got to this result.

[evroon]

Thank you!