Is there a faster way to compare arbitrary Python Objects than this?

[cgarciae]

Is there a faster way to compare arbitrary Python Objects than this? Currently slower than some pure python solutions.

use pyo3::prelude::*;

pub struct PyObjectWrapper {
    pub obj: PyObject,
}

impl PyObjectWrapper {
    pub fn new(obj: PyObject) -> Self {
        PyObjectWrapper { obj }
    }
}

impl PartialEq for PyObjectWrapper {
    fn eq(&self, other: &Self) -> bool {
        Python::with_gil(|py| -> PyResult<bool> {
            self.obj
                .call_method1(py, "__eq__", (&other.obj,))?
                .extract::<bool>(py)
        })
        .unwrap()
    }
}

impl Eq for PyObjectWrapper {}

impl PartialOrd for PyObjectWrapper {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        return Python::with_gil(|py| -> PyResult<std::cmp::Ordering> {
            let gt = self
                .obj
                .call_method1(py, "__gt__", (&other.obj,))?
                .extract::<bool>(py)?;
            if gt {
                return Ok(std::cmp::Ordering::Greater);
            }
            let lt = self
                .obj
                .call_method1(py, "__lt__", (&other.obj,))?
                .extract::<bool>(py)?;
            if lt {
                return Ok(std::cmp::Ordering::Less);
            }
            return Ok(std::cmp::Ordering::Equal);
        })
        .ok();
    }
}

impl Ord for PyObjectWrapper {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        return Python::with_gil(|py| -> PyResult<std::cmp::Ordering> {
            let operator = py.import("operator")?;
            let lt = operator.getattr("lt")?;
            let result = lt.call1((&self.obj, &other.obj))?;
            let result = result.extract::<bool>()?;
            if result {
                return Ok(std::cmp::Ordering::Less);
            }
            let gt = operator.getattr("gt")?;
            let result = gt.call1((&self.obj, &other.obj))?;
            let result = result.extract::<bool>()?;
            if result {
                return Ok(std::cmp::Ordering::Greater);
            }
            return Ok(std::cmp::Ordering::Equal);
        })
        .unwrap();
    }
}

[adamreichold]

If you need PyObjectWrapper to be 'static, then the cost of the with_gil call is most likely unavoidable.

You probably want to call PyAny::rich_compare (which safetly calls into the FFI PyObject_RichCompare) or where convenient use wrappers like PyAny::eq.

However, I suspect that this will never reach the speed of the pure Python solution due to the need for the GIL check which is most likely an unavoidable cost for safely managing Python objects using a Rust container.

[cgarciae]

Thanks! Will try it out :)

[cgarciae]

Can I just downcast it to PyAny if I don't know the types?

[adamreichold]

PyObject is just a type alias for Py<PyAny>, so call ob.as_ref(py) gives you a &PyAny if ob: &PyObject.