Switch to #[classmethod] for SpendBundle::py_aggregate

crates/chia-bls/src/public_key.rs

@@ -737,7 +737,8 @@ 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::from_json_dict(&py_class, string.bind(py)).unwrap();
                 assert_eq!(pk, pk2);
             });
         }
@@ -752,8 +753,9 @@ mod pytests {
     fn test_json_dict(#[case] input: &str, #[case] msg: &str) {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| {
-            let err =
-                PublicKey::from_json_dict(input.to_string().into_py(py).bind(py)).unwrap_err();
+            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();
             assert_eq!(err.value_bound(py).to_string(), msg.to_string());
         });
     }

crates/chia-bls/src/secret_key.rs

@@ -557,7 +557,8 @@ 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, string.bind(py)).unwrap();
                 assert_eq!(sk, sk2);
                 assert_eq!(sk.public_key(), sk2.public_key());
             });
@@ -588,8 +589,9 @@ mod pytests {
     fn test_json_dict(#[case] input: &str, #[case] msg: &str) {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| {
-            let err =
-                SecretKey::from_json_dict(input.to_string().into_py(py).bind(py)).unwrap_err();
+            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();
             assert_eq!(err.value_bound(py).to_string(), msg.to_string());
         });
     }

crates/chia-bls/src/signature.rs

@@ -1259,7 +1259,8 @@ 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, string.bind(py)).unwrap();
                 assert_eq!(sig, sig2);
             });
         }
@@ -1274,8 +1275,9 @@ mod pytests {
     fn test_json_dict(#[case] input: &str, #[case] msg: &str) {
         pyo3::prepare_freethreaded_python();
         Python::with_gil(|py| {
-            let err =
-                Signature::from_json_dict(input.to_string().into_py(py).bind(py)).unwrap_err();
+            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();
             assert_eq!(err.value_bound(py).to_string(), msg.to_string());
         });
     }

crates/chia-protocol/src/spend_bundle.rs

@@ -14,6 +14,8 @@ use clvmr::ENABLE_FIXED_DIV;
 
 #[cfg(feature = "py-bindings")]
 use pyo3::prelude::*;
+#[cfg(feature = "py-bindings")]
+use pyo3::types::PyType;
 
 #[streamable(subclass)]
 pub struct SpendBundle {
@@ -94,10 +96,10 @@ impl SpendBundle {
 #[pymethods]
 #[allow(clippy::needless_pass_by_value)]
 impl SpendBundle {
-    #[staticmethod]
+    #[classmethod]
     #[pyo3(name = "aggregate")]
-    fn py_aggregate(spend_bundles: Vec<SpendBundle>) -> SpendBundle {
-        SpendBundle::aggregate(&spend_bundles)
+    fn py_aggregate(_cls: &Bound<'_, PyType>, spend_bundles: Vec<Self>) -> Self {
+        Self::aggregate(&spend_bundles)
     }
 
     #[pyo3(name = "name")]

crates/chia_py_streamable_macro/src/lib.rs

@@ -159,9 +159,9 @@ pub fn py_streamable_macro(input: proc_macro::TokenStream) -> proc_macro::TokenS
     py_protocol.extend(quote! {
         #[pyo3::pymethods]
         impl #ident {
-            #[staticmethod]
+            #[classmethod]
             #[pyo3(signature=(json_dict))]
-            pub fn from_json_dict(json_dict: &pyo3::Bound<pyo3::PyAny>) -> pyo3::PyResult<Self> {
+            pub fn from_json_dict(_cls: &pyo3::Bound<'_, pyo3::types::PyType>, json_dict: &pyo3::Bound<pyo3::PyAny>) -> pyo3::PyResult<Self> {
                 <Self as #crate_name::from_json_dict::FromJsonDict>::from_json_dict(json_dict)
             }
 
@@ -174,9 +174,9 @@ pub fn py_streamable_macro(input: proc_macro::TokenStream) -> proc_macro::TokenS
     let streamable = quote! {
         #[pyo3::pymethods]
         impl #ident {
-            #[staticmethod]
+            #[classmethod]
             #[pyo3(name = "from_bytes")]
-            pub fn py_from_bytes(blob: pyo3::buffer::PyBuffer<u8>) -> pyo3::PyResult<Self> {
+            pub fn py_from_bytes(_cls: &pyo3::Bound<'_, pyo3::types::PyType>, blob: pyo3::buffer::PyBuffer<u8>) -> pyo3::PyResult<Self> {
                 if !blob.is_c_contiguous() {
                     panic!("from_bytes() must be called with a contiguous buffer");
                 }
@@ -186,9 +186,9 @@ pub fn py_streamable_macro(input: proc_macro::TokenStream) -> proc_macro::TokenS
                 <Self as #crate_name::Streamable>::from_bytes(slice).map_err(|e| <#crate_name::chia_error::Error as Into<pyo3::PyErr>>::into(e))
             }
 
-            #[staticmethod]
+            #[classmethod]
             #[pyo3(name = "from_bytes_unchecked")]
-            pub fn py_from_bytes_unchecked(blob: pyo3::buffer::PyBuffer<u8>) -> pyo3::PyResult<Self> {
+            pub fn py_from_bytes_unchecked(_cls: &pyo3::Bound<'_, pyo3::types::PyType>, blob: pyo3::buffer::PyBuffer<u8>) -> pyo3::PyResult<Self> {
                 if !blob.is_c_contiguous() {
                     panic!("from_bytes_unchecked() must be called with a contiguous buffer");
                 }
@@ -199,9 +199,9 @@ pub fn py_streamable_macro(input: proc_macro::TokenStream) -> proc_macro::TokenS
             }
 
             // returns the type as well as the number of bytes read from the buffer
-            #[staticmethod]
+            #[classmethod]
             #[pyo3(signature= (blob, trusted=false))]
-            pub fn parse_rust<'p>(blob: pyo3::buffer::PyBuffer<u8>, trusted: bool) -> pyo3::PyResult<(Self, u32)> {
+            pub fn parse_rust<'p>(_cls: &pyo3::Bound<'_, pyo3::types::PyType>, blob: pyo3::buffer::PyBuffer<u8>, trusted: bool) -> pyo3::PyResult<(Self, u32)> {
                 if !blob.is_c_contiguous() {
                     panic!("parse_rust() must be called with a contiguous buffer");
                 }

tests/test_spend_bundle.py

@@ -211,3 +211,15 @@ def test_spend_bundle(
 
     rem = f"{removals}"
     assert rem == expected_rem
+
+
+class NewAndImprovedSpendBundle(PySpendBundle):
+    test_bool = True
+
+
+def test_derive_class():
+    test = PySpendBundle.aggregate([])
+    assert isinstance(test, PySpendBundle)
+    test = NewAndImprovedSpendBundle.aggregate([])
+    assert isinstance(test, NewAndImprovedSpendBundle)
+    assert test.test_bool

wheel/generate_type_stubs.py

@@ -55,19 +55,19 @@ def __repr__(self) -> str: ...
     def __richcmp__(self) -> Any: ...
     def __deepcopy__(self) -> {name}: ...
     def __copy__(self) -> {name}: ...
-    @staticmethod
-    def from_bytes(bytes) -> {name}: ...
-    @staticmethod
-    def from_bytes_unchecked(bytes) -> {name}: ...
-    @staticmethod
-    def parse_rust(ReadableBuffer, bool = False) -> Tuple[{name}, int]: ...
+    @classmethod
+    def from_bytes(cls, bytes) -> {name}: ...
+    @classmethod
+    def from_bytes_unchecked(cls, bytes) -> {name}: ...
+    @classmethod
+    def parse_rust(cls, ReadableBuffer, bool = False) -> Tuple[{name}, int]: ...
     def to_bytes(self) -> bytes: ...
     def __bytes__(self) -> bytes: ...
     def stream_to_bytes(self) -> bytes: ...
     def get_hash(self) -> bytes32: ...
     def to_json_dict(self) -> Any: ...
-    @staticmethod
-    def from_json_dict(json_dict: Any) -> {name}: ...
+    @classmethod
+    def from_json_dict(cls, json_dict: Any) -> {name}: ...
 """
     )
 
@@ -222,7 +222,7 @@ def parse_rust_source(filename: str, upper_case: bool) -> List[Tuple[str, List[s
         "def uncurry(self) -> Tuple[ChiaProgram, ChiaProgram]: ...",
     ],
     "SpendBundle": [
-        "@staticmethod\n    def aggregate(sbs: List[SpendBundle]) -> SpendBundle: ...",
+        "@classmethod\n    def aggregate(sbs: List[SpendBundle]) -> SpendBundle: ...",
         "def name(self) -> bytes32: ...",
         "def removals(self) -> List[Coin]: ...",
         "def additions(self) -> List[Coin]: ...",