Switch to #[classmethod] for SpendBundle::py_aggregate

crates/chia-bls/src/public_key.rs

@@ -750,7 +750,7 @@ mod pytests {
             Python::with_gil(|py| {
                 let string = pk.to_json_dict(py).expect("to_json_dict");
                 let py_class = py.get_type_bound::<PublicKey>();
-                let pk2: PublicKey = PublicKey::from_json_dict(&py_class, string.bind(py))
+                let pk2: PublicKey = PublicKey::from_json_dict(&py_class, py, string.bind(py))
                     .unwrap()
                     .extract(py)
                     .unwrap();
@@ -769,8 +769,9 @@ mod pytests {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| {
             let py_class = py.get_type_bound::<PublicKey>();
-            let err = PublicKey::from_json_dict(&py_class, input.to_string().into_py(py).bind(py))
-                .unwrap_err();
+            let err =
+                PublicKey::from_json_dict(&py_class, py, input.to_string().into_py(py).bind(py))
+                    .unwrap_err();
             assert_eq!(err.value_bound(py).to_string(), msg.to_string());
         });
     }

crates/chia-bls/src/secret_key.rs

@@ -570,7 +570,7 @@ mod pytests {
             Python::with_gil(|py| {
                 let string = sk.to_json_dict(py).expect("to_json_dict");
                 let py_class = py.get_type_bound::<SecretKey>();
-                let sk2 = SecretKey::from_json_dict(&py_class, string.bind(py))
+                let sk2 = SecretKey::from_json_dict(&py_class, py, string.bind(py))
                     .unwrap()
                     .extract(py)
                     .unwrap();
@@ -605,8 +605,9 @@ mod pytests {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| {
             let py_class = py.get_type_bound::<SecretKey>();
-            let err = SecretKey::from_json_dict(&py_class, input.to_string().into_py(py).bind(py))
-                .unwrap_err();
+            let err =
+                SecretKey::from_json_dict(&py_class, py, input.to_string().into_py(py).bind(py))
+                    .unwrap_err();
             assert_eq!(err.value_bound(py).to_string(), msg.to_string());
         });
     }

crates/chia-bls/src/signature.rs

@@ -492,11 +492,12 @@ impl Signature {
 
     #[classmethod]
     #[pyo3(name = "from_parent")]
-    pub fn from_parent(_cls: &Bound<'_, PyType>, instance: Self) -> PyResult<PyObject> {
-        Python::with_gil(|py| {
-            // ignore child case
-            Ok(instance.into_py(py))
-        })
+    pub fn from_parent(
+        _cls: &Bound<'_, PyType>,
+        py: Python<'_>,
+        instance: Self,
+    ) -> PyResult<PyObject> {
+        Ok(instance.into_py(py))
     }
 
     #[pyo3(name = "pair")]
@@ -1272,7 +1273,7 @@ mod pytests {
             Python::with_gil(|py| {
                 let string = sig.to_json_dict(py).expect("to_json_dict");
                 let py_class = py.get_type_bound::<Signature>();
-                let sig2 = Signature::from_json_dict(&py_class, string.bind(py))
+                let sig2 = Signature::from_json_dict(&py_class, py, string.bind(py))
                     .unwrap()
                     .extract(py)
                     .unwrap();
@@ -1291,8 +1292,9 @@ mod pytests {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| {
             let py_class = py.get_type_bound::<Signature>();
-            let err = Signature::from_json_dict(&py_class, input.to_string().into_py(py).bind(py))
-                .unwrap_err();
+            let err =
+                Signature::from_json_dict(&py_class, py, input.to_string().into_py(py).bind(py))
+                    .unwrap_err();
             assert_eq!(err.value_bound(py).to_string(), msg.to_string());
         });
     }

crates/chia_py_streamable_macro/src/lib.rs

@@ -161,24 +161,23 @@ pub fn py_streamable_macro(input: proc_macro::TokenStream) -> proc_macro::TokenS
         impl #ident {
             #[classmethod]
             #[pyo3(signature=(json_dict))]
-            pub fn from_json_dict(cls: &pyo3::Bound<'_, pyo3::types::PyType>, json_dict: &pyo3::Bound<pyo3::PyAny>) -> pyo3::PyResult<pyo3::PyObject> {
+            pub fn from_json_dict(cls: &pyo3::Bound<'_, pyo3::types::PyType>, py: pyo3::Python<'_>, json_dict: &pyo3::Bound<pyo3::PyAny>) -> pyo3::PyResult<pyo3::PyObject> {
                 use pyo3::prelude::PyAnyMethods;
                 use pyo3::IntoPy;
                 use pyo3::type_object::PyTypeInfo;
                 use std::borrow::Borrow;
                 let rust_obj = <Self as #crate_name::from_json_dict::FromJsonDict>::from_json_dict(json_dict)?;
-                pyo3::Python::with_gil(|py| {
-                    // Check if python class is different from rust class (in case of child classes)
-                    // if so call the python class's conversion code
-
-                    let cls_type = cls.borrow().as_ref();
-                    if <Self as PyTypeInfo>::is_exact_type_of_bound(cls_type) {
-                        Ok(rust_obj.into_py(py))
-                    } else {
-                        let instance = cls.call_method1("from_parent", (rust_obj.into_py(py),))?;
-                        Ok(instance.into_py(py))
-                    }
-                })
+
+                // Check if python class is different from rust class (in case of child classes)
+                // if so call the python class's conversion code
+
+                let cls_type = cls.borrow().as_ref();
+                if <Self as PyTypeInfo>::is_exact_type_of_bound(cls_type) {
+                    Ok(rust_obj.into_py(py))
+                } else {
+                    let instance = cls.call_method1("from_parent", (rust_obj.into_py(py),))?;
+                    Ok(instance.into_py(py))
+                }
             }
 
             pub fn to_json_dict(&self, py: pyo3::Python) -> pyo3::PyResult<pyo3::PyObject> {
@@ -192,7 +191,7 @@ pub fn py_streamable_macro(input: proc_macro::TokenStream) -> proc_macro::TokenS
         impl #ident {
             #[classmethod]
             #[pyo3(name = "from_bytes")]
-            pub fn py_from_bytes(cls: &pyo3::Bound<'_, pyo3::types::PyType>, blob: pyo3::buffer::PyBuffer<u8>) -> pyo3::PyResult<pyo3::PyObject> {
+            pub fn py_from_bytes(cls: &pyo3::Bound<'_, pyo3::types::PyType>, py: pyo3::Python<'_>, blob: pyo3::buffer::PyBuffer<u8>) -> pyo3::PyResult<pyo3::PyObject> {
                 use pyo3::prelude::PyAnyMethods;
                 use pyo3::IntoPy;
                 use pyo3::type_object::PyTypeInfo;
@@ -205,23 +204,22 @@ pub fn py_streamable_macro(input: proc_macro::TokenStream) -> proc_macro::TokenS
                     std::slice::from_raw_parts(blob.buf_ptr() as *const u8, blob.len_bytes())
                 };
                 let rust_obj = <Self as #crate_name::Streamable>::from_bytes(slice)?;
-                pyo3::Python::with_gil(|py| {
-                    // Check if python class is different from rust class (in case of child classes)
-                    // if so call the python class's conversion code
-
-                    let cls_type = cls.borrow().as_ref();
-                    if <Self as PyTypeInfo>::is_exact_type_of_bound(cls_type) {
-                        Ok(rust_obj.into_py(py))
-                    } else {
-                        let instance = cls.call_method1("from_parent", (rust_obj.into_py(py),))?;
-                        Ok(instance.into_py(py))
-                    }
-                })
+
+                // Check if python class is different from rust class (in case of child classes)
+                // if so call the python class's conversion code
+
+                let cls_type = cls.borrow().as_ref();
+                if <Self as PyTypeInfo>::is_exact_type_of_bound(cls_type) {
+                    Ok(rust_obj.into_py(py))
+                } else {
+                    let instance = cls.call_method1("from_parent", (rust_obj.into_py(py),))?;
+                    Ok(instance.into_py(py))
+                }
             }
 
             #[classmethod]
             #[pyo3(name = "from_bytes_unchecked")]
-            pub fn py_from_bytes_unchecked(cls: &pyo3::Bound<'_, pyo3::types::PyType>, blob: pyo3::buffer::PyBuffer<u8>) -> pyo3::PyResult<pyo3::PyObject> {
+            pub fn py_from_bytes_unchecked(cls: &pyo3::Bound<'_, pyo3::types::PyType>, py: pyo3::Python<'_>, blob: pyo3::buffer::PyBuffer<u8>) -> pyo3::PyResult<pyo3::PyObject> {
                 use pyo3::prelude::PyAnyMethods;
                 use pyo3::IntoPy;
                 use pyo3::type_object::PyTypeInfo;
@@ -233,24 +231,23 @@ pub fn py_streamable_macro(input: proc_macro::TokenStream) -> proc_macro::TokenS
                     std::slice::from_raw_parts(blob.buf_ptr() as *const u8, blob.len_bytes())
                 };
                 let rust_obj = <Self as #crate_name::Streamable>::from_bytes_unchecked(slice).map_err(|e| <#crate_name::chia_error::Error as Into<pyo3::PyErr>>::into(e))?;
-                pyo3::Python::with_gil(|py| {
-                    // Check if python class is different from rust class (in case of child classes)
-                    // if so call the python class's conversion code
-
-                    let cls_type = cls.borrow().as_ref();
-                    if <Self as PyTypeInfo>::is_exact_type_of_bound(cls_type) {
-                        Ok(rust_obj.into_py(py))
-                    } else {
-                        let instance = cls.call_method1("from_parent", (rust_obj.into_py(py),))?;
-                        Ok(instance.into_py(py))
-                    }
-                })
+
+                // Check if python class is different from rust class (in case of child classes)
+                // if so call the python class's conversion code
+
+                let cls_type = cls.borrow().as_ref();
+                if <Self as PyTypeInfo>::is_exact_type_of_bound(cls_type) {
+                    Ok(rust_obj.into_py(py))
+                } else {
+                    let instance = cls.call_method1("from_parent", (rust_obj.into_py(py),))?;
+                    Ok(instance.into_py(py))
+                }
             }
 
             // returns the type as well as the number of bytes read from the buffer
             #[classmethod]
             #[pyo3(signature= (blob, trusted=false))]
-            pub fn parse_rust<'p>(cls: &pyo3::Bound<'_, pyo3::types::PyType>, blob: pyo3::buffer::PyBuffer<u8>, trusted: bool) -> pyo3::PyResult<(pyo3::PyObject, u32)> {
+            pub fn parse_rust<'p>(cls: &pyo3::Bound<'_, pyo3::types::PyType>, py: pyo3::Python<'_>, blob: pyo3::buffer::PyBuffer<u8>, trusted: bool) -> pyo3::PyResult<(pyo3::PyObject, u32)> {
                 use pyo3::prelude::PyAnyMethods;
                 use pyo3::IntoPy;
                 use pyo3::type_object::PyTypeInfo;
@@ -267,18 +264,17 @@ pub fn py_streamable_macro(input: proc_macro::TokenStream) -> proc_macro::TokenS
                 } else {
                     <Self as #crate_name::Streamable>::parse::<false>(&mut input).map_err(|e| <#crate_name::chia_error::Error as Into<pyo3::PyErr>>::into(e)).map(|v| (v, input.position() as u32))
                 }?;
-                pyo3::Python::with_gil(|py| {
-                    // Check if python class is different from rust class (in case of child classes)
-                    // if so call the python class's conversion code
-
-                    let cls_type = cls.borrow().as_ref();
-                    if <Self as PyTypeInfo>::is_exact_type_of_bound(cls_type) {
-                        Ok((rust_obj.0.into_py(py), rust_obj.1))
-                    } else {
-                        let instance = cls.call_method1("from_parent", (rust_obj.0.into_py(py),))?;
-                        Ok((instance.into_py(py), rust_obj.1))
-                    }
-                })
+
+                // Check if python class is different from rust class (in case of child classes)
+                // if so call the python class's conversion code
+
+                let cls_type = cls.borrow().as_ref();
+                if <Self as PyTypeInfo>::is_exact_type_of_bound(cls_type) {
+                    Ok((rust_obj.0.into_py(py), rust_obj.1))
+                } else {
+                    let instance = cls.call_method1("from_parent", (rust_obj.0.into_py(py),))?;
+                    Ok((instance.into_py(py), rust_obj.1))
+                }
             }
 
             pub fn get_hash<'p>(&self, py: pyo3::Python<'p>) -> pyo3::PyResult<pyo3::Bound<'p, pyo3::types::PyAny>> {