Tuple from iterable

[kevinhartman]

I frequently find myself writing code like this to efficiently build a tuple from an iterable:

fn as_tuple(py: Python<'_>, seq: &Bound<PyAny>) -> PyResult<Py<PyTuple>> {
    if seq.is_instance_of::<PyTuple>() {
        Ok(seq.downcast_exact::<PyTuple>()?.into_py(py))
    } else if seq.is_instance_of::<PyList>() {
        let seq = seq.downcast_exact::<PyList>()?;
        Ok(seq.to_tuple().unbind())
    } else {
        // New tuple from iterable.
        Ok(PyTuple::new_bound(
            py,
            seq.iter()?
                .map(|o| Ok(o?.unbind()))
                .collect::<PyResult<Vec<PyObject>>>()?,
        )
        .unbind())
    }
}

Is there a better way to do this? As I understand it, downcasting should be faster if seq is actually already a tuple (calling tuple() on something in CPython is a no-op I believe if the thing is already a tuple, and I'd like those semantics here.

(FWIW, I realize this code could probably be even faster if I were to skip the is_instance_of check and instead handle the PyResult returned from downcast_exact.)

[mejrs]

You can call PySequence_Tuple or https://docs.rs/pyo3/latest/pyo3/types/trait.PySequenceMethods.html#tymethod.to_tuple

[kevinhartman]

Thanks, though I'm not sure I understand.

I've got a PyAny, and I need to convert that to a PyTuple. How would I get to PySequence from PyAny?

[mejrs]

You can just take PySequence as an argument instead of PyAny.

[dimaqq]

CPython has a special callable_iterator type that perhaps could be abused here. YMMV.

[dimaqq]

Another option: just call tuple on it:

In [1]: def iterable():
   ...:     yield 1
   ...:     yield 2
   ...:

In [2]: tuple(iterable())
Out[2]: (1, 2)

Thus

#[pyfunction]
fn test_tuple(py: Python<'_>, arg: Bound<'_, PyAny>) -> PyResult<PyObject> {
    let builtins = PyModule::import(py, "builtins")?;
    let rv = builtins.call_method1("tuple", (arg.as_ref(),))?;
    Ok(rv.unbind())
}