Best way of transforming a struct from an external library into a #[pyclass]

[MartinJepsen]

Related:

• Sharing Rust structs in foreign libraries / Writing complex wrapper classes #3634: Using pub struct PyRustStruct(external_crate::RustStruct) does the trick, but still requires decorating all structs.

Hello,

I have a Rust library with a lot of structs. Most of them have primitive-typed fields. I want to transform them into read-only #[pyclass] so their fields are exposed in Python in a read-only fashion.

What I want to achieve

Let's take this struct as an example:

pub struct RustStruct {
    pub field1: i32,
    pub field2: String,
}

I wish to transform this struct into another Python-compatible struct (#[pyclass]) with the following properties:

• Has the name of the original struct, prefixed by Py
• Has a #[getter] for each public field.
• I'm not interested in instantiating these structs in Python, so it's fine if there's no #[new].

Based on these properties, RustStruct should be transformed into

#[pyclass]
pub struct PyRustStruct {
   #[pyo3(get)]
   pub field1: i32
   #[pyo3(get)]
   pub field2: String
}

Approaches I've considered

I've mainly considered writing a macro that wraps RustStruct and simply generates the equivalent PyRustStruct in the following way:

extern crate proc_macro;
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, Field, Fields, ItemStruct};

#[proc_macro]
pub fn generate_pyclass_wrapper(input: TokenStream) -> TokenStream {
    // Parse the input token stream into a struct
    let input = parse_macro_input!(input as ItemStruct);
    // Extract the struct's name and fields
    let struct_name = &input.ident;

    let fields = match &input.fields {
        Fields::Named(fields) => &fields.named,
        _ => panic!("Only structs with named fields are supported."),
    };

    // Generate the field definitions for the struct
    let field_defs = fields.iter().map(|field: &Field| {
        let field_name = &field.ident;
        let field_type = &field.ty;
        let field_vis = &field.vis;
        quote! {
            #[pyo3(get)]
            #field_vis #field_name: #field_type
        }
    });


    // Generate the #[pyclass] and #[pymethods] implementation
    let expanded = quote! {
        use pyo3::prelude::*;

        // Define the Python class with the name "Py" followed by the struct name
        #[pyclass]
        pub struct Py,#struct_name {
            #(#field_defs);*  // The fields of the struct
        }

    };

    TokenStream::from(expanded)
}

The corresponding call to transform RustStruct would then be:

use pyo3::prelude::*;
use pywrap_macro::generate_pyclass_wrapper;

generate_pyclass_wrapper!(RustStruct);

However, It looks like I can't access the struct definition merely from the identifier RustStruct, as it won't parse into an ItemStruct. So far, the only solution I've found is to generate a derive macro, that wraps the entire struct definition or decorates the struct definition, like so:

#[generate_pyclass_wrapper]
struct RustStruct {...}

# or

generate_pyclass_wrapper!(
    struct RustStruct {...}
)

But that would require me to alter the structs where they are defined. Because they come from an external crate, It's not ideal to do this.

Any suggestions are welcome!