pyo3/conversions/
smallvec.rs

1#![cfg(feature = "smallvec")]
2
3//!  Conversions to and from [smallvec](https://docs.rs/smallvec/).
4//!
5//! # Setup
6//!
7//! To use this feature, add this to your **`Cargo.toml`**:
8//!
9//! ```toml
10//! [dependencies]
11//! # change * to the latest versions
12//! smallvec = "*"
13#![doc = concat!("pyo3 = { version = \"", env!("CARGO_PKG_VERSION"),  "\", features = [\"smallvec\"] }")]
14//! ```
15//!
16//! Note that you must use compatible versions of smallvec and PyO3.
17//! The required smallvec version may vary based on the version of PyO3.
18use crate::conversion::IntoPyObject;
19use crate::exceptions::PyTypeError;
20#[cfg(feature = "experimental-inspect")]
21use crate::inspect::types::TypeInfo;
22use crate::types::any::PyAnyMethods;
23use crate::types::{PySequence, PyString};
24use crate::PyErr;
25use crate::{err::DowncastError, ffi, Bound, FromPyObject, PyAny, PyResult, Python};
26use smallvec::{Array, SmallVec};
27
28impl<'py, A> IntoPyObject<'py> for SmallVec<A>
29where
30    A: Array,
31    A::Item: IntoPyObject<'py>,
32{
33    type Target = PyAny;
34    type Output = Bound<'py, Self::Target>;
35    type Error = PyErr;
36
37    /// Turns [`SmallVec<u8>`] into [`PyBytes`], all other `T`s will be turned into a [`PyList`]
38    ///
39    /// [`PyBytes`]: crate::types::PyBytes
40    /// [`PyList`]: crate::types::PyList
41    #[inline]
42    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
43        <A::Item>::owned_sequence_into_pyobject(self, py, crate::conversion::private::Token)
44    }
45
46    #[cfg(feature = "experimental-inspect")]
47    fn type_output() -> TypeInfo {
48        TypeInfo::list_of(A::Item::type_output())
49    }
50}
51
52impl<'a, 'py, A> IntoPyObject<'py> for &'a SmallVec<A>
53where
54    A: Array,
55    &'a A::Item: IntoPyObject<'py>,
56    A::Item: 'a, // MSRV
57{
58    type Target = PyAny;
59    type Output = Bound<'py, Self::Target>;
60    type Error = PyErr;
61
62    #[inline]
63    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
64        self.as_slice().into_pyobject(py)
65    }
66
67    #[cfg(feature = "experimental-inspect")]
68    fn type_output() -> TypeInfo {
69        TypeInfo::list_of(<&A::Item>::type_output())
70    }
71}
72
73impl<'py, A> FromPyObject<'py> for SmallVec<A>
74where
75    A: Array,
76    A::Item: FromPyObject<'py>,
77{
78    fn extract_bound(obj: &Bound<'py, PyAny>) -> PyResult<Self> {
79        if obj.is_instance_of::<PyString>() {
80            return Err(PyTypeError::new_err("Can't extract `str` to `SmallVec`"));
81        }
82        extract_sequence(obj)
83    }
84
85    #[cfg(feature = "experimental-inspect")]
86    fn type_input() -> TypeInfo {
87        TypeInfo::sequence_of(A::Item::type_input())
88    }
89}
90
91fn extract_sequence<'py, A>(obj: &Bound<'py, PyAny>) -> PyResult<SmallVec<A>>
92where
93    A: Array,
94    A::Item: FromPyObject<'py>,
95{
96    // Types that pass `PySequence_Check` usually implement enough of the sequence protocol
97    // to support this function and if not, we will only fail extraction safely.
98    let seq = unsafe {
99        if ffi::PySequence_Check(obj.as_ptr()) != 0 {
100            obj.downcast_unchecked::<PySequence>()
101        } else {
102            return Err(DowncastError::new(obj, "Sequence").into());
103        }
104    };
105
106    let mut sv = SmallVec::with_capacity(seq.len().unwrap_or(0));
107    for item in seq.try_iter()? {
108        sv.push(item?.extract::<A::Item>()?);
109    }
110    Ok(sv)
111}
112
113#[cfg(test)]
114mod tests {
115    use super::*;
116    use crate::types::{PyBytes, PyBytesMethods, PyDict, PyList};
117
118    #[test]
119    fn test_smallvec_from_py_object() {
120        Python::with_gil(|py| {
121            let l = PyList::new(py, [1, 2, 3, 4, 5]).unwrap();
122            let sv: SmallVec<[u64; 8]> = l.extract().unwrap();
123            assert_eq!(sv.as_slice(), [1, 2, 3, 4, 5]);
124        });
125    }
126
127    #[test]
128    fn test_smallvec_from_py_object_fails() {
129        Python::with_gil(|py| {
130            let dict = PyDict::new(py);
131            let sv: PyResult<SmallVec<[u64; 8]>> = dict.extract();
132            assert_eq!(
133                sv.unwrap_err().to_string(),
134                "TypeError: 'dict' object cannot be converted to 'Sequence'"
135            );
136        });
137    }
138
139    #[test]
140    fn test_smallvec_into_pyobject() {
141        Python::with_gil(|py| {
142            let sv: SmallVec<[u64; 8]> = [1, 2, 3, 4, 5].iter().cloned().collect();
143            let hso = sv.into_pyobject(py).unwrap();
144            let l = PyList::new(py, [1, 2, 3, 4, 5]).unwrap();
145            assert!(l.eq(hso).unwrap());
146        });
147    }
148
149    #[test]
150    fn test_smallvec_intopyobject_impl() {
151        Python::with_gil(|py| {
152            let bytes: SmallVec<[u8; 8]> = [1, 2, 3, 4, 5].iter().cloned().collect();
153            let obj = bytes.clone().into_pyobject(py).unwrap();
154            assert!(obj.is_instance_of::<PyBytes>());
155            let obj = obj.downcast_into::<PyBytes>().unwrap();
156            assert_eq!(obj.as_bytes(), &*bytes);
157
158            let nums: SmallVec<[u16; 8]> = [1, 2, 3, 4, 5].iter().cloned().collect();
159            let obj = nums.into_pyobject(py).unwrap();
160            assert!(obj.is_instance_of::<PyList>());
161        });
162    }
163}
pyo3/conversions/smallvec.rs

pyo3/conversions/
smallvec.rs
