Method extract

src/array_like.rs:143–190

(ob: Borrowed<'a, 'py, PyAny>)

    type Error = PyErr;

    fn extract(ob: Borrowed<'a, 'py, PyAny>) -> PyResult<Self> {
        if let Ok(array) = ob.cast::<PyArray<T, D>>() {
            return Ok(Self(array.readonly(), PhantomData));
        }

        let py = ob.py();

        // If the input is already an ndarray and `TypeMustMatch` is used then no type conversion
        // should be performed.
        if (C::ALLOW_TYPE_CHANGE || ob.cast::<PyUntypedArray>().is_err())
            && matches!(D::NDIM, None | Some(1))
        {
            if let Ok(vec) = ob.extract::<Vec<T>>() {
                let array = Array1::from(vec)
                    .into_dimensionality()
                    .expect("D being compatible to Ix1")
                    .into_pyarray(py)
                    .readonly();
                return Ok(Self(array, PhantomData));
            }
        }

        let (dtype, flags) = if C::ALLOW_TYPE_CHANGE {
            (Some(T::get_dtype(py)), NPY_ARRAY_FORCECAST)
        } else {
            (None, 0)
        };

        let newtype = dtype
            .map(|dt| dt.into_ptr().cast())
            .unwrap_or_else(std::ptr::null_mut);

        let array = unsafe {
            let ptr = PY_ARRAY_API.PyArray_FromAny(
                py,
                ob.as_ptr(),
                newtype,
                0,
                0,
                flags,
                std::ptr::null_mut(),
            );

            pyo3::Bound::from_owned_ptr_or_err(py, ptr)?
        };

        Ok(Self(array.extract()?, PhantomData))
    }
}

/// Receiver for zero-dimensional arrays or array-like types.