Merge pull request #160 from kevinheavey/pyo3-26

upgrade to pyo3 0.26

Author: kevinheavey

Cargo.lock

@@ -16,7 +16,7 @@ crate-type = ["cdylib", "rlib"]
 [dependencies]
 bincode = { workspace = true }
 derive_more = { workspace = true }
-pyo3 = { workspace = true, features = ["macros", "extension-module", "abi3-py37"] }
+pyo3 = { workspace = true, features = ["macros", "extension-module", "abi3-py38"] }
 serde = { workspace = true }
 solana-address-lookup-table-interface = { workspace = true }
 solana-sdk-ids = { workspace = true }
@@ -71,8 +71,8 @@ derive_more = "0.99.17"
 five8 = "0.2.1"
 litesvm = "0.8"
 log = "0.4"
-pyo3 = { version = "0.23", default-features = false }
-pythonize = "0.23"
+pyo3 = { version = "0.26", default-features = false }
+pythonize = "0.26"
 serde = "^1.0.188"
 serde_bytes = "0.11.12"
 serde_cbor = "^0.11.2"
@@ -174,3 +174,6 @@ spl-token-interface = "2"
 thiserror = "^1.0.31"
 time = "0.3.35"
 zeroize = "1.7"
+
+[patch.crates-io]
+dict_derive = { path = "crates/dict-derive" }

Cargo.toml

@@ -99,8 +99,8 @@ impl ParsedAccount {
     }
 
     #[getter]
-    pub fn parsed(&self, py: Python<'_>) -> PyResult<PyObject> {
-        handle_py_value_err(pythonize(py, &self.0.parsed))
+    pub fn parsed(&self, py: Python<'_>) -> PyResult<Py<PyAny>> {
+        handle_py_value_err(pythonize(py, &self.0.parsed).map(Bound::unbind))
     }
 
     #[getter]

crates/account-decoder/src/lib.rs

@@ -0,0 +1,16 @@
+[package]
+name = "dict_derive"
+version = "0.6.0"
+edition = "2018"
+authors = ["Guilherme Perinazzo <[email protected]>"]
+description = "Derive macros for some PyO3 traits to convert python dicts into rust structs"
+license = "Apache-2.0"
+repository = "https://github.com/gperinazzo/dict-derive"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+proc-macro2 = "1"
+quote = "1"
+syn = { version = "1", features = ["full"] }

crates/dict-derive/Cargo.toml

@@ -0,0 +1,134 @@
+use proc_macro2::TokenStream;
+use quote::{quote, quote_spanned, ToTokens};
+use syn::{parse_quote, spanned::Spanned, Data, DeriveInput, Field, Ident};
+
+fn is_option(ty: &syn::Type) -> bool {
+    let path = match *ty {
+        syn::Type::Path(ref p) if p.qself.is_none() => &p.path,
+        _ => return false,
+    };
+
+    path.segments
+        .iter()
+        .map(|segment| segment.ident.to_string())
+        .any(|x| x.as_str() == "Option")
+}
+
+fn map_extraction(field: Field) -> TokenStream {
+    let ident = match &field.ident {
+        Some(i) => i,
+        None => {
+            return syn::Error::new(field.span(), "Unnamed fields are not supported")
+                .to_compile_error()
+        }
+    };
+
+    let name = ident.to_string();
+
+    let function = if is_option(&field.ty) {
+        Ident::new("extract_optional", field.ty.span())
+    } else {
+        Ident::new("extract_required", field.ty.span())
+    };
+
+    quote_spanned! {ident.span()=>
+        #ident: #function(dict, #name)?
+    }
+}
+
+fn extraction_functions() -> TokenStream {
+    quote! {
+        fn map_exception(name: &str, e: PyErr) -> PyErr {
+            PyErr::new::<PyTypeError, _>(format!("Unable to convert key: {}. Error: {}", name, e))
+        }
+
+        fn extract_required<'a, T>(dict: &Bound<'a, PyDict>, name: &str) -> PyResult<T>
+        where
+            T: FromPyObject<'a>,
+        {
+            match PyDictMethods::get_item(dict, name)? {
+                Some(v) => FromPyObject::extract_bound(&v)
+                    .map_err(|err| map_exception(name, err)),
+                None => Err(PyErr::new::<PyValueError, _>(format!(
+                    "Missing required key: {}",
+                    name
+                ))),
+            }
+        }
+
+        fn extract_optional<'a, T>(dict: &Bound<'a, PyDict>, name: &str) -> PyResult<std::option::Option<T>>
+        where
+            T: FromPyObject<'a>,
+        {
+            match PyDictMethods::get_item(dict, name)? {
+                Some(v) => FromPyObject::extract_bound(&v)
+                    .map_err(|err| map_exception(name, err)),
+                None => Ok(None),
+            }
+        }
+    }
+}
+
+pub fn from_impl(ast: DeriveInput) -> TokenStream {
+    let struct_data = match ast.data {
+        Data::Struct(s) => s,
+        Data::Enum(e) => {
+            return syn::Error::new(e.enum_token.span, "Deriving enums is not supported")
+                .to_compile_error();
+        }
+        Data::Union(u) => {
+            return syn::Error::new(u.union_token.span, "Deriving unions is not supported")
+                .to_compile_error();
+        }
+    };
+
+    let extractions = struct_data.fields.into_iter().map(map_extraction);
+
+    let name = ast.ident;
+    let mut impl_generics = ast.generics.clone();
+
+    let lifetimes_count = impl_generics.lifetimes().count();
+
+    if lifetimes_count > 1 {
+        return syn::Error::new(
+            impl_generics.span(),
+            "Deriving structs with more than one lifetime is not supported",
+        )
+        .to_compile_error();
+    } else if lifetimes_count == 0 {
+        impl_generics.params.push(parse_quote!('source));
+    };
+
+    let lifetime = impl_generics
+        .lifetimes()
+        .next()
+        .map(|lt| lt.lifetime.to_token_stream())
+        .unwrap();
+
+    let (_, ty_generics, where_clause) = ast.generics.split_for_impl();
+    let (impl_generics, _, _) = impl_generics.split_for_impl();
+
+    let functions = extraction_functions();
+
+    quote! {
+        impl #impl_generics ::pyo3::FromPyObject<#lifetime> for #name #ty_generics #where_clause {
+            fn extract_bound(
+                obj: &::pyo3::prelude::Bound<#lifetime, ::pyo3::types::PyAny>,
+            ) -> ::pyo3::PyResult<Self> {
+                use ::pyo3::{FromPyObject, PyErr, PyResult};
+                use ::pyo3::exceptions::{PyTypeError, PyValueError};
+                use ::pyo3::prelude::Bound;
+                use ::pyo3::types::{PyAnyMethods, PyDict, PyDictMethods};
+                let dict = obj.downcast::<PyDict>().map_err(|_| {
+                    PyErr::new::<PyTypeError, _>("Invalid type to convert, expected dict")
+                })?;
+
+                #functions
+
+                ::std::result::Result::Ok(#name {
+                    #(#extractions),*
+                })
+            }
+        }
+    }
+}

crates/dict-derive/src/from.rs

@@ -0,0 +1,57 @@
+use proc_macro2::TokenStream;
+use quote::{quote, quote_spanned};
+use syn::{parse_quote, spanned::Spanned, Data, DeriveInput, Field};
+
+fn map_fields(field: Field) -> TokenStream {
+    let ident = match &field.ident {
+        Some(i) => i,
+        None => {
+            return syn::Error::new(field.span(), "Unnamed fields are not supported")
+                .to_compile_error()
+        }
+    };
+
+    let name = ident.to_string();
+
+    quote_spanned! {field.ty.span()=>
+        dict.set_item(#name, self.#ident)?;
+    }
+}
+
+pub fn into_impl(ast: DeriveInput) -> TokenStream {
+    let struct_data = match ast.data {
+        Data::Struct(s) => s,
+        Data::Enum(e) => {
+            return syn::Error::new(e.enum_token.span, "Deriving enums is not supported")
+                .to_compile_error();
+        }
+        Data::Union(u) => {
+            return syn::Error::new(u.union_token.span, "Deriving unions is not supported")
+                .to_compile_error();
+        }
+    };
+
+    let field_setters = struct_data.fields.into_iter().map(map_fields);
+
+    let name = ast.ident;
+    let (_, ty_generics, where_clause) = ast.generics.split_for_impl();
+
+    let mut impl_generics = ast.generics.clone();
+    impl_generics.params.insert(0, parse_quote!('py));
+    let (impl_generics, _, _) = impl_generics.split_for_impl();
+
+    quote! {
+        impl #impl_generics ::pyo3::IntoPyObject<'py> for #name #ty_generics #where_clause {
+            type Target = ::pyo3::types::PyDict;
+            type Output = ::pyo3::Bound<'py, ::pyo3::types::PyDict>;
+            type Error = ::pyo3::PyErr;
+
+            fn into_pyobject(self, py: ::pyo3::Python<'py>) -> ::pyo3::PyResult<Self::Output> {
+                use ::pyo3::types::PyDict;
+                let dict = PyDict::new(py);
+                #(#field_setters)*
+                ::std::result::Result::Ok(dict)
+            }
+        }
+    }
+}

crates/dict-derive/src/into.rs

@@ -0,0 +1,19 @@
+mod from;
+mod into;
+
+use from::from_impl;
+use into::into_impl;
+use proc_macro::TokenStream;
+use syn::DeriveInput;
+
+#[proc_macro_derive(FromPyObject)]
+pub fn derive_from_py_object(input: TokenStream) -> TokenStream {
+    let ast = syn::parse_macro_input!(input as DeriveInput);
+    TokenStream::from(from_impl(ast))
+}
+
+#[proc_macro_derive(IntoPyObject)]
+pub fn derive_into_py_object(input: TokenStream) -> TokenStream {
+    let ast = syn::parse_macro_input!(input as DeriveInput);
+    TokenStream::from(into_impl(ast))
+}