how to use FromPyObjectBound ?

[AriBermeki]

hi @davidhewitt , sorry to bother you, I ask you too many questions but I have to.

in which cases I need to implement FromPyObjectBound, please give me an example.

I'm working on a really big project, it's about creating a framework for web-based desktop applications like Tauri in Rust for Python, so I need to understand your Pyo3 API so I don't have to use the Pipe(Stdin/Stdout).

use pyo3::conversion::FromPyObjectBound;
use pyo3::prelude::*;
use pyo3::types::PyDict;

#[derive(Debug)]
struct User {
    name: String,
    age: u32,
}


#[derive(Debug)]
struct Product {
    name: String,
    price: f64,
    in_stock: bool,
}




impl<'a, 'py> FromPyObjectBound<'a, 'py> for User {
    fn from_py_object_bound(ob: Borrowed<'a, 'py, PyAny>) -> PyResult<Self> {
        let dict = ob.downcast::<PyDict>()?;
        let name = dict.get_item("name")?.expect("REASON").extract::<String>()?;
        let age = dict.get_item("age")?.expect("REASON").extract::<u32>()?;
        Ok(User { name, age })
    }
}








impl<'source> FromPyObject<'source> for User {
    fn extract_bound(ob: &Bound<'source, PyAny>) -> PyResult<Self> {
        let dict = ob.downcast::<PyDict>()?;
        let name = dict.get_item("name")?.expect("REASON").extract::<String>()?;
        let age = dict.get_item("age")?.expect("REASON").extract::<u32>()?;
        Ok(User { name, age })
    }
}





impl IntoPy<PyObject> for Product {
    fn into_py(self, py: Python<'_>) -> PyObject {
        let dict = PyDict::new_bound(py);
        dict.set_item("name", self.name).unwrap();
        dict.set_item("price", self.price).unwrap();
        dict.set_item("in_stock", self.in_stock).unwrap();
        dict.into()
    }
}



impl ToPyObject for Product {
    
    fn to_object(&self, py: Python<'_>) -> PyObject {
        let dict = PyDict::new_bound(py);
        dict.set_item("name", self.name.clone()).unwrap();
        dict.set_item("price", self.price).unwrap();
        dict.set_item("in_stock", self.in_stock).unwrap();
        dict.into()
    }
}




#[pyfunction]
fn process_user_with_from_py_object_bound(py: Python<'_>, user_dict: &PyDict) -> PyResult<String> {
    let borrowed_dict: Borrowed<PyAny> = user_dict.into();
    let user: User = User::from_py_object_bound(borrowed_dict)?;
    Ok(format!("User: {:?}", user))
}




#[pyfunction]
fn create_product_with_intopy(name: String, price: f64, in_stock: bool) -> PyResult<Py<PyAny>> {
    let product = Product { name, price, in_stock };
    Ok(Python::with_gil(|py| product.into_py(py)))
}



#[pyfunction]
fn create_product_with_to_pyobject(name: String, price: f64, in_stock: bool) -> PyResult<Py<PyAny>> {
    let product = Product { name, price, in_stock };
    Ok(Python::with_gil(|py| product.to_object(py)))
}



#[pyfunction]
fn process_user_with_from_py_object(user: User) -> PyResult<String> {
    Ok(format!("Process Users: {} ({})", user.name, user.age))
}






/// A Python module implemented in Rust.
#[pymodule]
fn mymodule(m: &Bound<'_, PyModule>) -> PyResult<()> {
   m.add_function(wrap_pyfunction!(process_user_with_from_py_object, m)?)?;
   m.add_function(wrap_pyfunction!(create_product_with_to_pyobject, m)?)?;
   m.add_function(wrap_pyfunction!(process_user_with_from_py_object_bound, m)?)?;
   m.add_function(wrap_pyfunction!(create_product_with_intopy, m)?)?;
    Ok(())
}

[davidhewitt]

FromPyObjectBound is only necessary if the extra lifetime 'a needs to be connected to your type.

For the example above, it is not necessary, your impl could be written with placeholder lifetimes:

impl FromPyObjectBound<'_, '_> for User

... so just implement FromPyObject and it'll be sufficient.

but really, here this type looks trivial and you should just use #[derive(FromPyObject)].

[davidhewitt]

An example where PyO3 does use FromPyObjectBound is &str. The implementation is written:

impl<'a> FromPyObjectBound<'a, '_> for &'a str

[AriBermeki]

This was just an experiment to understand these APIs.

But I think you need to explicitly implement From PyObject if the struct "User" has methods, or does From PyObject automatically detect the parameter types of the methods?

While conducting the experiments, I somehow got the impression that ToPyObject and IntoPy have the same effect. Does IntoPy have the implementation of ToPyObject?

If you have 5 minutes to make this code compatible with pyo3 version 0.22.0 I would be really grateful. I want the framework to support both synchronous and asynchronous operations. I don't know how to implement this with the latest version of pyo3 using Futchers(pyo3 = { version = "0.22.0", features = ["multiple-pymethods","experimental-async"] }
) please @davidhewitt 🙏🏼🙏🏼🙏🏼🙏🏼.

use std::sync::Arc;

use anyhow::Result;
use log::debug;
use pyo3::prelude::*;
use pyo3_asyncio::TaskLocals;
use pyo3::{prelude::*, types::PyDict};

#[pyclass]
#[derive(Debug)]
pub struct PythonCommandInfo {
    #[pyo3(get, set)]
    pub handler: Py<PyAny>,
    #[pyo3(get, set)]
    pub is_async: bool,
    #[pyo3(get, set)]
    pub number_of_params: u8,
    #[pyo3(get, set)]
    pub args: Py<PyDict>,
    #[pyo3(get, set)]
    pub kwargs: Py<PyDict>,
}

#[pymethods]
impl PythonCommandInfo {
    #[new]
    pub fn new(
        handler: Py<PyAny>,
        is_async: bool,
        number_of_params: u8,
        args: Py<PyDict>,
        kwargs: Py<PyDict>,
    ) -> Self {
        Self {
            handler,
            is_async,
            number_of_params,
            args,
            kwargs,
        }
    }
}

#[inline]
fn get_function_output<'a, T>(
    function: &'a PythonCommandInfo,
    py: Python<'a>,
    function_args: &T,
) -> Result<&'a PyAny, PyErr>
where
    T: ToPyObject,
{
    let handler = function.handler.as_ref(py);
    let kwargs = function.kwargs.as_ref(py);
    let function_args = function_args.to_object(py);
    debug!("Function args: {:?}", function_args);

    match function.number_of_params {
        0 => handler.call0(),
        1 => {
            handler.call1((function_args,))
        }
        _ => handler.call((function_args,), Some(kwargs)),
    }
}




pub async fn execute_python_command_handler(
    event_handler: Option<Arc<PythonCommandInfo>>,
    task_locals: &TaskLocals,
) -> Result<()> {
    if let Some(function) = event_handler {
        if function.is_async {
            debug!("Startup event handler async");
            Python::with_gil(|py| {
                pyo3_asyncio::into_future_with_locals(
                    task_locals,
                    function.handler.as_ref(py).call0()?,
                )
            })?
            .await?;
        } else {
            debug!("Startup event handler");
            Python::with_gil(|py| function.handler.call0(py))?;
        }
    }
    Ok(())
}

#[pymodule]
fn pyframe(m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_class::<PythonCommandInfo>()?;
    Ok(())
}

[davidhewitt]

But I think you need to explicitly implement From PyObject if the struct "User" has methods, or does From PyObject automatically detect the parameter types of the methods?

I'm not sure I follow here, maybe you can write a quick example?

While conducting the experiments, I somehow got the impression that ToPyObject and IntoPy have the same effect. Does IntoPy have the implementation of ToPyObject?

They are heavily overlapping, we plan to simplify and replace both with an IntoPyObject trait in 0.23.

If you have 5 minutes to make this code compatible with pyo3 version 0.22.0

I see you have pyo3-asyncio; that doesn't support 0.22 yet, you should watch out for a release on https://github.com/PyO3/pyo3-async-runtimes which is our new fork