feat: Support for mappingproxy objects

newsfragments/3521.added.md

@@ -0,0 +1 @@
+Add `PyMappingProxy` type.

pyo3-ffi/src/descrobject.rs

@@ -1,6 +1,6 @@
 use crate::methodobject::PyMethodDef;
 use crate::object::{PyObject, PyTypeObject};
-use crate::Py_ssize_t;
+use crate::{PyObject_TypeCheck, Py_ssize_t};
 use std::os::raw::{c_char, c_int, c_void};
 use std::ptr;
 
@@ -68,6 +68,11 @@ extern "C" {
     pub fn PyWrapper_New(arg1: *mut PyObject, arg2: *mut PyObject) -> *mut PyObject;
 }
 
+#[inline]
+pub unsafe fn PyDictProxy_Check(op: *mut PyObject) -> c_int {
+    PyObject_TypeCheck(op, std::ptr::addr_of_mut!(PyDictProxy_Type))
+}
+
 /// Represents the [PyMemberDef](https://docs.python.org/3/c-api/structures.html#c.PyMemberDef)
 /// structure.
 ///

src/conversions/hashbrown.rs

@@ -18,7 +18,7 @@
 //! The required hashbrown version may vary based on the version of PyO3.
 use crate::{
     types::set::new_from_iter,
-    types::{IntoPyDict, PyDict, PySet},
+    types::{IntoPyDict, PyDict, PyMappingProxy, PySet},
     FromPyObject, IntoPy, PyAny, PyErr, PyObject, PyResult, Python, ToPyObject,
 };
 use std::{cmp, hash};
@@ -55,12 +55,30 @@ where
     S: hash::BuildHasher + Default,
 {
     fn extract(ob: &'source PyAny) -> Result<Self, PyErr> {
-        let dict: &PyDict = ob.downcast()?;
-        let mut ret = hashbrown::HashMap::with_capacity_and_hasher(dict.len(), S::default());
-        for (k, v) in dict {
-            ret.insert(K::extract(k)?, V::extract(v)?);
+        match ob.downcast::<PyDict>() {
+            Ok(dict) => {
+                let mut ret =
+                    hashbrown::HashMap::with_capacity_and_hasher(dict.len(), S::default());
+                for (k, v) in dict {
+                    ret.insert(K::extract(k)?, V::extract(v)?);
+                }
+                Ok(ret)
+            }
+            Err(msg) => {
+                if let Ok(mappingproxy) = ob.downcast::<PyMappingProxy>() {
+                    let mut ret = hashbrown::HashMap::with_capacity_and_hasher(
+                        mappingproxy.len().unwrap_or_default(),
+                        S::default(),
+                    );
+                    for (k, v) in mappingproxy {
+                        ret.insert(K::extract(k)?, V::extract(v)?);
+                    }
+                    Ok(ret)
+                } else {
+                    Err(PyErr::from(msg))
+                }
+            }
         }
-        Ok(ret)
     }
 }
 
@@ -101,6 +119,7 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::types::IntoPyMappingProxy;
 
     #[test]
     fn test_hashbrown_hashmap_to_python() {
@@ -186,4 +205,26 @@ mod tests {
             assert_eq!(hs, hso.extract(py).unwrap());
         });
     }
+
+    #[test]
+    fn test_hashbrown_hashmap_into_mapping_proxy() {
+        Python::with_gil(|py| {
+            let mut map = hashbrown::HashMap::<i32, i32>::new();
+            map.insert(1, 1);
+
+            let mappingproxy = map.clone().into_py_mappingproxy(py).unwrap();
+
+            assert_eq!(mappingproxy.len().unwrap(), 1);
+            assert_eq!(
+                mappingproxy.get_item(1).unwrap().extract::<i32>().unwrap(),
+                1
+            );
+            assert_eq!(
+                map,
+                mappingproxy
+                    .extract::<hashbrown::HashMap::<i32, i32>>()
+                    .unwrap()
+            );
+        });
+    }
 }

src/conversions/indexmap.rs

@@ -123,12 +123,30 @@ where
     S: hash::BuildHasher + Default,
 {
     fn extract(ob: &'source PyAny) -> Result<Self, PyErr> {
-        let dict: &PyDict = ob.downcast()?;
-        let mut ret = indexmap::IndexMap::with_capacity_and_hasher(dict.len(), S::default());
-        for (k, v) in dict {
-            ret.insert(K::extract(k)?, V::extract(v)?);
+        match ob.downcast::<PyDict>() {
+            Ok(dict) => {
+                let mut ret =
+                    indexmap::IndexMap::with_capacity_and_hasher(dict.len(), S::default());
+                for (k, v) in dict {
+                    ret.insert(K::extract(k)?, V::extract(v)?);
+                }
+                Ok(ret)
+            }
+            Err(msg) => {
+                if let Ok(mappingproxy) = ob.downcast::<PyMappingProxy>() {
+                    let mut ret = indexmap::IndexMap::with_capacity_and_hasher(
+                        mappingproxy.len().unwrap_or_default(),
+                        S::default(),
+                    );
+                    for (k, v) in mappingproxy {
+                        ret.insert(K::extract(k)?, V::extract(v)?);
+                    }
+                    Ok(ret)
+                } else {
+                    Err(PyErr::from(msg))
+                }
+            }
         }
-        Ok(ret)
     }
 }
 
@@ -236,4 +254,26 @@ mod test_indexmap {
             }
         });
     }
+
+    #[test]
+    fn test_indexmap_indexmap_into_mappingproxy() {
+        Python::with_gil(|py| {
+            let mut map = indexmap::IndexMap::<i32, i32>::new();
+            map.insert(1, 1);
+
+            let mappingproxy = map.clone().into_py_mappingproxy(py).unwrap();
+
+            assert_eq!(mappingproxy.len().unwrap(), 1);
+            assert_eq!(
+                mappingproxy.get_item(1).unwrap().extract::<i32>().unwrap(),
+                1
+            );
+            assert_eq!(
+                map,
+                mappingproxy
+                    .extract::<indexmap::IndexMap<i32, i32>>()
+                    .unwrap()
+            );
+        });
+    }
 }

src/conversions/std/map.rs

@@ -3,7 +3,7 @@ use std::{cmp, collections, hash};
 #[cfg(feature = "experimental-inspect")]
 use crate::inspect::types::TypeInfo;
 use crate::{
-    types::{IntoPyDict, PyDict},
+    types::{IntoPyDict, PyDict, PyMappingProxy},
     FromPyObject, IntoPy, PyAny, PyErr, PyObject, Python, ToPyObject,
 };
 
@@ -72,12 +72,30 @@ where
     S: hash::BuildHasher + Default,
 {
     fn extract(ob: &'source PyAny) -> Result<Self, PyErr> {
-        let dict: &PyDict = ob.downcast()?;
-        let mut ret = collections::HashMap::with_capacity_and_hasher(dict.len(), S::default());
-        for (k, v) in dict {
-            ret.insert(K::extract(k)?, V::extract(v)?);
+        match ob.downcast::<PyDict>() {
+            Ok(dict) => {
+                let mut ret =
+                    collections::HashMap::with_capacity_and_hasher(dict.len(), S::default());
+                for (k, v) in dict {
+                    ret.insert(K::extract(k)?, V::extract(v)?);
+                }
+                Ok(ret)
+            }
+            Err(msg) => {
+                if let Ok(mappingproxy) = ob.downcast::<PyMappingProxy>() {
+                    let mut ret = collections::HashMap::with_capacity_and_hasher(
+                        mappingproxy.len().unwrap_or_default(),
+                        S::default(),
+                    );
+                    for (k, v) in mappingproxy {
+                        ret.insert(K::extract(k)?, V::extract(v)?);
+                    }
+                    Ok(ret)
+                } else {
+                    Err(PyErr::from(msg))
+                }
+            }
         }
-        Ok(ret)
     }
 
     #[cfg(feature = "experimental-inspect")]
@@ -92,12 +110,26 @@ where
     V: FromPyObject<'source>,
 {
     fn extract(ob: &'source PyAny) -> Result<Self, PyErr> {
-        let dict: &PyDict = ob.downcast()?;
-        let mut ret = collections::BTreeMap::new();
-        for (k, v) in dict {
-            ret.insert(K::extract(k)?, V::extract(v)?);
+        match ob.downcast::<PyDict>() {
+            Ok(dict) => {
+                let mut ret = collections::BTreeMap::new();
+                for (k, v) in dict {
+                    ret.insert(K::extract(k)?, V::extract(v)?);
+                }
+                Ok(ret)
+            }
+            Err(msg) => {
+                if let Ok(mappingproxy) = ob.downcast::<PyMappingProxy>() {
+                    let mut ret = collections::BTreeMap::new();
+                    for (k, v) in mappingproxy {
+                        ret.insert(K::extract(k)?, V::extract(v)?);
+                    }
+                    Ok(ret)
+                } else {
+                    Err(PyErr::from(msg))
+                }
+            }
         }
-        Ok(ret)
     }
 
     #[cfg(feature = "experimental-inspect")]