Switch to #[classmethod] for SpendBundle::py_aggregate

crates/chia-bls/src/gtelement.rs

@@ -2,6 +2,12 @@ use blst::*;
 use chia_traits::chia_error::Result;
 use chia_traits::{read_bytes, Streamable};
 use clvmr::sha2::Sha256;
+#[cfg(feature = "py-bindings")]
+use pyo3::exceptions::PyNotImplementedError;
+#[cfg(feature = "py-bindings")]
+use pyo3::prelude::*;
+#[cfg(feature = "py-bindings")]
+use pyo3::types::PyType;
 use std::fmt;
 use std::hash::{Hash, Hasher};
 use std::io::Cursor;
@@ -112,6 +118,14 @@ impl GTElement {
         hex::encode(self.to_bytes())
     }
 
+    #[classmethod]
+    #[pyo3(name = "from_parent")]
+    pub fn from_parent(_cls: &Bound<'_, PyType>, _instance: &Self) -> PyResult<PyObject> {
+        Err(PyNotImplementedError::new_err(
+            "GTElement does not support from_parent().",
+        ))
+    }
+
     #[must_use]
     pub fn __mul__(&self, rhs: &Self) -> Self {
         let mut ret = self.clone();
@@ -130,7 +144,6 @@ mod pybindings {
 
     use crate::parse_hex::parse_hex_string;
     use chia_traits::{FromJsonDict, ToJsonDict};
-    use pyo3::prelude::*;
 
     impl ToJsonDict for GTElement {
         fn to_json_dict(&self, py: Python<'_>) -> PyResult<PyObject> {

crates/chia-bls/src/public_key.rs

@@ -4,6 +4,12 @@ use crate::{DerivableKey, Error, Result};
 use blst::*;
 use chia_traits::{read_bytes, Streamable};
 use clvmr::sha2::Sha256;
+#[cfg(feature = "py-bindings")]
+use pyo3::exceptions::PyNotImplementedError;
+#[cfg(feature = "py-bindings")]
+use pyo3::prelude::*;
+#[cfg(feature = "py-bindings")]
+use pyo3::types::PyType;
 use std::fmt;
 use std::hash::{Hash, Hasher};
 use std::io::Cursor;
@@ -321,6 +327,14 @@ impl PublicKey {
         other.pair(self)
     }
 
+    #[classmethod]
+    #[pyo3(name = "from_parent")]
+    pub fn from_parent(_cls: &Bound<'_, PyType>, _instance: &Self) -> PyResult<PyObject> {
+        Err(PyNotImplementedError::new_err(
+            "PublicKey does not support from_parent().",
+        ))
+    }
+
     #[pyo3(name = "get_fingerprint")]
     pub fn py_get_fingerprint(&self) -> u32 {
         self.get_fingerprint()
@@ -353,7 +367,6 @@ mod pybindings {
     use crate::parse_hex::parse_hex_string;
 
     use chia_traits::{FromJsonDict, ToJsonDict};
-    use pyo3::prelude::*;
 
     impl ToJsonDict for PublicKey {
         fn to_json_dict(&self, py: Python<'_>) -> PyResult<PyObject> {
@@ -737,7 +750,11 @@ mod pytests {
             let pk = sk.public_key();
             Python::with_gil(|py| {
                 let string = pk.to_json_dict(py).expect("to_json_dict");
-                let pk2 = PublicKey::from_json_dict(string.bind(py)).unwrap();
+                let py_class = py.get_type_bound::<PublicKey>();
+                let pk2: PublicKey = PublicKey::from_json_dict(&py_class, py, string.bind(py))
+                    .unwrap()
+                    .extract(py)
+                    .unwrap();
                 assert_eq!(pk, pk2);
             });
         }
@@ -752,8 +769,10 @@ mod pytests {
     fn test_json_dict(#[case] input: &str, #[case] msg: &str) {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| {
+            let py_class = py.get_type_bound::<PublicKey>();
             let err =
-                PublicKey::from_json_dict(input.to_string().into_py(py).bind(py)).unwrap_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

@@ -3,6 +3,12 @@ use blst::*;
 use chia_traits::{read_bytes, Streamable};
 use clvmr::sha2::Sha256;
 use hkdf::HkdfExtract;
+#[cfg(feature = "py-bindings")]
+use pyo3::exceptions::PyNotImplementedError;
+#[cfg(feature = "py-bindings")]
+use pyo3::prelude::*;
+#[cfg(feature = "py-bindings")]
+use pyo3::types::PyType;
 use std::fmt;
 use std::hash::{Hash, Hasher};
 use std::io::Cursor;
@@ -266,6 +272,14 @@ impl SecretKey {
         hex::encode(self.to_bytes())
     }
 
+    #[classmethod]
+    #[pyo3(name = "from_parent")]
+    pub fn from_parent(_cls: &Bound<'_, PyType>, _instance: &Self) -> PyResult<PyObject> {
+        Err(PyNotImplementedError::new_err(
+            "SecretKey does not support from_parent().",
+        ))
+    }
+
     #[pyo3(name = "derive_hardened")]
     #[must_use]
     pub fn py_derive_hardened(&self, idx: u32) -> Self {
@@ -292,7 +306,6 @@ mod pybindings {
     use crate::parse_hex::parse_hex_string;
 
     use chia_traits::{FromJsonDict, ToJsonDict};
-    use pyo3::prelude::*;
 
     impl ToJsonDict for SecretKey {
         fn to_json_dict(&self, py: Python<'_>) -> PyResult<PyObject> {
@@ -557,7 +570,11 @@ mod pytests {
             let sk = SecretKey::from_seed(&data);
             Python::with_gil(|py| {
                 let string = sk.to_json_dict(py).expect("to_json_dict");
-                let sk2 = SecretKey::from_json_dict(string.bind(py)).unwrap();
+                let py_class = py.get_type_bound::<SecretKey>();
+                let sk2 = SecretKey::from_json_dict(&py_class, py, string.bind(py))
+                    .unwrap()
+                    .extract(py)
+                    .unwrap();
                 assert_eq!(sk, sk2);
                 assert_eq!(sk.public_key(), sk2.public_key());
             });
@@ -588,8 +605,10 @@ mod pytests {
     fn test_json_dict(#[case] input: &str, #[case] msg: &str) {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| {
+            let py_class = py.get_type_bound::<SecretKey>();
             let err =
-                SecretKey::from_json_dict(input.to_string().into_py(py).bind(py)).unwrap_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

@@ -2,6 +2,12 @@ use crate::{Error, GTElement, PublicKey, Result, SecretKey};
 use blst::*;
 use chia_traits::{read_bytes, Streamable};
 use clvmr::sha2::Sha256;
+#[cfg(feature = "py-bindings")]
+use pyo3::exceptions::PyNotImplementedError;
+#[cfg(feature = "py-bindings")]
+use pyo3::prelude::*;
+#[cfg(feature = "py-bindings")]
+use pyo3::types::PyType;
 use std::borrow::Borrow;
 use std::fmt;
 use std::hash::{Hash, Hasher};
@@ -486,6 +492,14 @@ impl Signature {
         Self::default()
     }
 
+    #[classmethod]
+    #[pyo3(name = "from_parent")]
+    pub fn from_parent(_cls: &Bound<'_, PyType>, _instance: &Self) -> PyResult<PyObject> {
+        Err(PyNotImplementedError::new_err(
+            "Signature does not support from_parent().",
+        ))
+    }
+
     #[pyo3(name = "pair")]
     pub fn py_pair(&self, other: &PublicKey) -> GTElement {
         self.pair(other)
@@ -518,7 +532,6 @@ mod pybindings {
     use crate::parse_hex::parse_hex_string;
 
     use chia_traits::{FromJsonDict, ToJsonDict};
-    use pyo3::prelude::*;
 
     impl ToJsonDict for Signature {
         fn to_json_dict(&self, py: Python<'_>) -> PyResult<PyObject> {
@@ -1259,7 +1272,11 @@ mod pytests {
             let sig = sign(&sk, msg);
             Python::with_gil(|py| {
                 let string = sig.to_json_dict(py).expect("to_json_dict");
-                let sig2 = Signature::from_json_dict(string.bind(py)).unwrap();
+                let py_class = py.get_type_bound::<Signature>();
+                let sig2 = Signature::from_json_dict(&py_class, py, string.bind(py))
+                    .unwrap()
+                    .extract(py)
+                    .unwrap();
                 assert_eq!(sig, sig2);
             });
         }
@@ -1274,8 +1291,10 @@ mod pytests {
     fn test_json_dict(#[case] input: &str, #[case] msg: &str) {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| {
+            let py_class = py.get_type_bound::<Signature>();
             let err =
-                Signature::from_json_dict(input.to_string().into_py(py).bind(py)).unwrap_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-consensus/src/gen/owned_conditions.rs

@@ -8,6 +8,13 @@ use super::conditions::{SpendBundleConditions, SpendConditions};
 #[cfg(feature = "py-bindings")]
 use chia_py_streamable_macro::{PyJsonDict, PyStreamable};
 
+#[cfg(feature = "py-bindings")]
+use pyo3::exceptions::PyNotImplementedError;
+#[cfg(feature = "py-bindings")]
+use pyo3::prelude::*;
+#[cfg(feature = "py-bindings")]
+use pyo3::types::PyType;
+
 #[derive(Streamable, Hash, Debug, Clone, Eq, PartialEq)]
 #[cfg_attr(
     feature = "py-bindings",
@@ -144,3 +151,27 @@ fn convert_agg_sigs(a: &Allocator, agg_sigs: &[(PublicKey, NodePtr)]) -> Vec<(Pu
     }
     ret
 }
+
+#[cfg(feature = "py-bindings")]
+#[pymethods]
+impl OwnedSpendConditions {
+    #[classmethod]
+    #[pyo3(name = "from_parent")]
+    pub fn from_parent(_cls: &Bound<'_, PyType>, _instance: &Self) -> PyResult<PyObject> {
+        Err(PyNotImplementedError::new_err(
+            "OwnedSpendConditions does not support from_parent().",
+        ))
+    }
+}
+
+#[cfg(feature = "py-bindings")]
+#[pymethods]
+impl OwnedSpendBundleConditions {
+    #[classmethod]
+    #[pyo3(name = "from_parent")]
+    pub fn from_parent(_cls: &Bound<'_, PyType>, _instance: &Self) -> PyResult<PyObject> {
+        Err(PyNotImplementedError::new_err(
+            "OwnedSpendBundleConditions does not support from_parent().",
+        ))
+    }
+}

crates/chia-protocol/src/coin.rs

@@ -6,8 +6,12 @@ use clvm_traits::{
 };
 use clvmr::sha2::Sha256;
 
+#[cfg(feature = "py-bindings")]
+use pyo3::exceptions::PyNotImplementedError;
 #[cfg(feature = "py-bindings")]
 use pyo3::prelude::*;
+#[cfg(feature = "py-bindings")]
+use pyo3::types::PyType;
 
 #[streamable]
 #[derive(Copy)]
@@ -55,6 +59,18 @@ impl Coin {
     }
 }
 
+#[cfg(feature = "py-bindings")]
+#[pymethods]
+impl Coin {
+    #[classmethod]
+    #[pyo3(name = "from_parent")]
+    pub fn from_parent(_cls: &Bound<'_, PyType>, _coin: Self) -> PyResult<PyObject> {
+        Err(PyNotImplementedError::new_err(
+            "Coin does not support from_parent().",
+        ))
+    }
+}
+
 impl<N, E: ClvmEncoder<Node = N>> ToClvm<E> for Coin {
     fn to_clvm(&self, encoder: &mut E) -> Result<N, ToClvmError> {
         clvm_list!(self.parent_coin_info, self.puzzle_hash, self.amount).to_clvm(encoder)

crates/chia-protocol/src/coin_spend.rs

@@ -2,10 +2,27 @@ use chia_streamable_macro::streamable;
 
 use crate::coin::Coin;
 use crate::program::Program;
+#[cfg(feature = "py-bindings")]
+use pyo3::prelude::*;
+#[cfg(feature = "py-bindings")]
+use pyo3::types::PyType;
 
 #[streamable]
 pub struct CoinSpend {
     coin: Coin,
     puzzle_reveal: Program,
     solution: Program,
 }
+
+#[cfg(feature = "py-bindings")]
+#[pymethods]
+impl CoinSpend {
+    #[classmethod]
+    #[pyo3(name = "from_parent")]
+    pub fn from_parent(cls: &Bound<'_, PyType>, py: Python<'_>, cs: Self) -> PyResult<PyObject> {
+        // Convert result into potential child class
+        let instance = cls.call1((cs.coin, cs.puzzle_reveal, cs.solution))?;
+
+        Ok(instance.into_py(py))
+    }
+}

crates/chia-protocol/src/program.rs

@@ -12,6 +12,10 @@ use clvmr::serde::{
 };
 use clvmr::sha2::Sha256;
 use clvmr::{Allocator, ChiaDialect};
+#[cfg(feature = "py-bindings")]
+use pyo3::prelude::*;
+#[cfg(feature = "py-bindings")]
+use pyo3::types::PyType;
 use std::io::Cursor;
 use std::ops::Deref;
 
@@ -152,9 +156,6 @@ use chia_traits::{FromJsonDict, ToJsonDict};
 #[cfg(feature = "py-bindings")]
 use chia_py_streamable_macro::PyStreamable;
 
-#[cfg(feature = "py-bindings")]
-use pyo3::prelude::*;
-
 #[cfg(feature = "py-bindings")]
 use pyo3::types::{PyList, PyTuple};
 
@@ -486,6 +487,18 @@ impl ToJsonDict for Program {
     }
 }
 
+#[cfg(feature = "py-bindings")]
+#[pymethods]
+impl Program {
+    #[classmethod]
+    #[pyo3(name = "from_parent")]
+    pub fn from_parent(_cls: &Bound<'_, PyType>, _instance: &Self) -> PyResult<PyObject> {
+        Err(PyNotImplementedError::new_err(
+            "This class does not support from_parent().",
+        ))
+    }
+}
+
 #[cfg(feature = "py-bindings")]
 impl FromJsonDict for Program {
     fn from_json_dict(o: &Bound<'_, PyAny>) -> PyResult<Self> {