pyo3/conversions/
hashbrown.rs

1#![cfg(feature = "hashbrown")]
2
3//!  Conversions to and from [hashbrown](https://docs.rs/hashbrown/)’s
4//! `HashMap` and `HashSet`.
5//!
6//! # Setup
7//!
8//! To use this feature, add this to your **`Cargo.toml`**:
9//!
10//! ```toml
11//! [dependencies]
12//! # change * to the latest versions
13//! hashbrown = "*"
14#![doc = concat!("pyo3 = { version = \"", env!("CARGO_PKG_VERSION"),  "\", features = [\"hashbrown\"] }")]
15//! ```
16//!
17//! Note that you must use compatible versions of hashbrown and PyO3.
18//! The required hashbrown version may vary based on the version of PyO3.
19use crate::{
20    conversion::IntoPyObject,
21    types::{
22        any::PyAnyMethods,
23        dict::PyDictMethods,
24        frozenset::PyFrozenSetMethods,
25        set::{try_new_from_iter, PySetMethods},
26        PyDict, PyFrozenSet, PySet,
27    },
28    Bound, FromPyObject, PyAny, PyErr, PyResult, Python,
29};
30use std::{cmp, hash};
31
32impl<'py, K, V, H> IntoPyObject<'py> for hashbrown::HashMap<K, V, H>
33where
34    K: IntoPyObject<'py> + cmp::Eq + hash::Hash,
35    V: IntoPyObject<'py>,
36    H: hash::BuildHasher,
37{
38    type Target = PyDict;
39    type Output = Bound<'py, Self::Target>;
40    type Error = PyErr;
41
42    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
43        let dict = PyDict::new(py);
44        for (k, v) in self {
45            dict.set_item(k, v)?;
46        }
47        Ok(dict)
48    }
49}
50
51impl<'a, 'py, K, V, H> IntoPyObject<'py> for &'a hashbrown::HashMap<K, V, H>
52where
53    &'a K: IntoPyObject<'py> + cmp::Eq + hash::Hash,
54    &'a V: IntoPyObject<'py>,
55    H: hash::BuildHasher,
56{
57    type Target = PyDict;
58    type Output = Bound<'py, Self::Target>;
59    type Error = PyErr;
60
61    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
62        let dict = PyDict::new(py);
63        for (k, v) in self {
64            dict.set_item(k, v)?;
65        }
66        Ok(dict)
67    }
68}
69
70impl<'py, K, V, S> FromPyObject<'py> for hashbrown::HashMap<K, V, S>
71where
72    K: FromPyObject<'py> + cmp::Eq + hash::Hash,
73    V: FromPyObject<'py>,
74    S: hash::BuildHasher + Default,
75{
76    fn extract_bound(ob: &Bound<'py, PyAny>) -> Result<Self, PyErr> {
77        let dict = ob.downcast::<PyDict>()?;
78        let mut ret = hashbrown::HashMap::with_capacity_and_hasher(dict.len(), S::default());
79        for (k, v) in dict {
80            ret.insert(k.extract()?, v.extract()?);
81        }
82        Ok(ret)
83    }
84}
85
86impl<'py, K, H> IntoPyObject<'py> for hashbrown::HashSet<K, H>
87where
88    K: IntoPyObject<'py> + cmp::Eq + hash::Hash,
89    H: hash::BuildHasher,
90{
91    type Target = PySet;
92    type Output = Bound<'py, Self::Target>;
93    type Error = PyErr;
94
95    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
96        try_new_from_iter(py, self)
97    }
98}
99
100impl<'a, 'py, K, H> IntoPyObject<'py> for &'a hashbrown::HashSet<K, H>
101where
102    &'a K: IntoPyObject<'py> + cmp::Eq + hash::Hash,
103    H: hash::BuildHasher,
104{
105    type Target = PySet;
106    type Output = Bound<'py, Self::Target>;
107    type Error = PyErr;
108
109    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
110        try_new_from_iter(py, self)
111    }
112}
113
114impl<'py, K, S> FromPyObject<'py> for hashbrown::HashSet<K, S>
115where
116    K: FromPyObject<'py> + cmp::Eq + hash::Hash,
117    S: hash::BuildHasher + Default,
118{
119    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<Self> {
120        match ob.downcast::<PySet>() {
121            Ok(set) => set.iter().map(|any| any.extract()).collect(),
122            Err(err) => {
123                if let Ok(frozen_set) = ob.downcast::<PyFrozenSet>() {
124                    frozen_set.iter().map(|any| any.extract()).collect()
125                } else {
126                    Err(PyErr::from(err))
127                }
128            }
129        }
130    }
131}
132
133#[cfg(test)]
134mod tests {
135    use super::*;
136    use crate::types::IntoPyDict;
137
138    #[test]
139    fn test_hashbrown_hashmap_into_pyobject() {
140        Python::with_gil(|py| {
141            let mut map = hashbrown::HashMap::<i32, i32>::new();
142            map.insert(1, 1);
143
144            let py_map = (&map).into_pyobject(py).unwrap();
145
146            assert!(py_map.len() == 1);
147            assert!(
148                py_map
149                    .get_item(1)
150                    .unwrap()
151                    .unwrap()
152                    .extract::<i32>()
153                    .unwrap()
154                    == 1
155            );
156            assert_eq!(map, py_map.extract().unwrap());
157        });
158    }
159
160    #[test]
161    fn test_hashbrown_hashmap_into_dict() {
162        Python::with_gil(|py| {
163            let mut map = hashbrown::HashMap::<i32, i32>::new();
164            map.insert(1, 1);
165
166            let py_map = map.into_py_dict(py).unwrap();
167
168            assert_eq!(py_map.len(), 1);
169            assert_eq!(
170                py_map
171                    .get_item(1)
172                    .unwrap()
173                    .unwrap()
174                    .extract::<i32>()
175                    .unwrap(),
176                1
177            );
178        });
179    }
180
181    #[test]
182    fn test_extract_hashbrown_hashset() {
183        Python::with_gil(|py| {
184            let set = PySet::new(py, [1, 2, 3, 4, 5]).unwrap();
185            let hash_set: hashbrown::HashSet<usize> = set.extract().unwrap();
186            assert_eq!(hash_set, [1, 2, 3, 4, 5].iter().copied().collect());
187
188            let set = PyFrozenSet::new(py, [1, 2, 3, 4, 5]).unwrap();
189            let hash_set: hashbrown::HashSet<usize> = set.extract().unwrap();
190            assert_eq!(hash_set, [1, 2, 3, 4, 5].iter().copied().collect());
191        });
192    }
193
194    #[test]
195    fn test_hashbrown_hashset_into_pyobject() {
196        Python::with_gil(|py| {
197            let hs: hashbrown::HashSet<u64> = [1, 2, 3, 4, 5].iter().cloned().collect();
198
199            let hso = hs.clone().into_pyobject(py).unwrap();
200
201            assert_eq!(hs, hso.extract().unwrap());
202        });
203    }
204}
pyo3/conversions/hashbrown.rs

pyo3/conversions/
hashbrown.rs
