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!

[davidhewitt]

This is a hard problem. The only other idea I've heard of is to build something to use rustdoc to generate JSON output about the external library types, and then to generate wrapper code from that JSON output.

However I think the JSON output is still not available on stable rust so you'd have to reach for nightly...