Merge pull request #27 from Jij-Inc/pr/LockedThread/22

Minor revise of #22

Author: termoshtt

src/de.rs

@@ -328,9 +328,20 @@ impl<'de> de::Deserializer<'de> for PyAnyDeserializer<'_> {
         if self.0.is_instance_of::<PyFloat>() {
             return visitor.visit_f64(self.0.extract()?);
         }
+        if self.0.hasattr("__dict__")? {
+            return visitor.visit_map(MapDeserializer::new(
+                self.0.getattr("__dict__")?.downcast()?,
+            ));
+        }
+        if self.0.hasattr("__slots__")? {
+            // __slots__ and __dict__ are mutually exclusive, see
+            // https://docs.python.org/3/reference/datamodel.html#slots
+            return visitor.visit_map(MapDeserializer::from_slots(&self.0)?);
+        }
         if self.0.is_none() {
             return visitor.visit_none();
         }
+
         unreachable!("Unsupported type: {}", self.0.get_type());
     }
 
@@ -498,6 +509,18 @@ impl<'py> MapDeserializer<'py> {
         }
         Self { keys, values }
     }
+
+    fn from_slots(obj: &Bound<'py, PyAny>) -> Result<Self> {
+        let mut keys = vec![];
+        let mut values = vec![];
+        for key in obj.getattr("__slots__")?.try_iter()? {
+            let key = key?;
+            keys.push(key.clone());
+            let v = obj.getattr(key.str()?)?;
+            values.push(v);
+        }
+        Ok(Self { keys, values })
+    }
 }
 
 impl<'de> MapAccess<'de> for MapDeserializer<'_> {

tests/check_revertible.rs

@@ -1,5 +1,5 @@
 use maplit::hashmap;
-use pyo3::prelude::*;
+use pyo3::{ffi::c_str, prelude::*};
 use serde::{Deserialize, Serialize};
 use serde_pyobject::{from_pyobject, to_pyobject};
 
@@ -133,3 +133,50 @@ fn struct_variant() {
         b: 30,
     });
 }
+
+#[test]
+fn check_python_object() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct MyClass {
+        name: String,
+        age: i32,
+    }
+
+    Python::with_gil(|py| {
+        // Create an instance of Python object
+        py.run(
+            c_str!(
+                r#"
+class MyClass:
+    def __init__(self, name: str, age: int):
+        self.name = name
+        self.age = age
+        "#
+            ),
+            None,
+            None,
+        )
+        .unwrap();
+        // Create an instance of MyClass
+        let my_python_class = py
+            .eval(
+                c_str!(
+                    r#"
+MyClass("John", 30)
+"#
+                ),
+                None,
+                None,
+            )
+            .unwrap();
+
+        let my_rust_class = MyClass {
+            name: "John".to_string(),
+            age: 30,
+        };
+        let any: Bound<'_, PyAny> = to_pyobject(py, &my_rust_class).unwrap();
+        let rust_version: MyClass = from_pyobject(my_python_class).unwrap();
+        let python_version: MyClass = from_pyobject(any).unwrap();
+        assert_eq!(rust_version, python_version);
+    })
+}