Struct Codegen

pub struct Codegen { /* private fields */ }

Engine for automatic generation of Rust FFI bindings to Python modules.

Examples

Here is a simple example of how to use the Codegen engine to generate Rust FFI bindings for the full os and sys Python modules. With the default configuration, all submodules, classes, functions, and parameters will be recursively parsed and included in the generated bindings.

fn main() -> Result<(), Box<dyn std::error::Error>> {
    Codegen::new(Config::default())
        .module_name("os")?
        .module_name("sys")?
        .generate()?;
    Ok(())
}

For more focused generation, paths to specific submodules can be provided. In the following example, only the entities and parser submodules of the html module will be included in the generated bindings alongside their respective submodules, classes, functions, and parameters. No direct attributes or submodules of the html top-level module will be included.

fn main() -> Result<(), Box<dyn std::error::Error>> {
    Codegen::default()
        .module_names(["html.entities", "html.parser"])?
        .generate()?;
    Ok(())
}

Implementations

impl Codegen

pub fn new(cfg: Config) -> Codegen

Create a new Codegen engine with the given configuration.

pub fn module( self, module: &Bound<'_, PyModule>, ) -> Result<Codegen, PyBindgenError>

Add a Python module to the list of modules for which to generate bindings.

pub fn module_name(self, module_name: &str) -> Result<Codegen, PyBindgenError>

Add a Python module by its name to the list of modules for which to generate bindings.

pub fn module_from_str( self, source_code: &str, module_name: &str, ) -> Result<Codegen, PyBindgenError>

Add a Python module from its source code and name to the list of modules for which to generate bindings.

Note

When including a module in this way, the Python source code must be available also during runtime for the underlying Python interpreter.

For convenience, you can call module_name::pyo3_embed_python_source_code() that is automatically generated in the Rust bindings. This function must be called before attempting to use any functions of classes from the module.

pub fn modules<'py>( self, modules: impl AsRef<[Bound<'py, PyModule>]>, ) -> Result<Codegen, PyBindgenError>

Add multiple Python modules to the list of modules for which to generate bindings.

pub fn module_names<'a>( self, module_names: impl AsRef<[&'a str]>, ) -> Result<Codegen, PyBindgenError>

Add multiple Python modules by their names to the list of modules for which to generate bindings.

pub fn generate(self) -> Result<TokenStream, PyBindgenError>

Generate the Rust FFI bindings for all modules added to the engine.

pub fn build(self, output_path: impl AsRef<Path>) -> Result<(), PyBindgenError>

Generate the Rust FFI bindings for all modules added to the engine and write them to the given file. This is a convenience method that combines generate and std::fs::write.

Trait Implementations

impl Clone for Codegen

fn clone(&self) -> Codegen

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Codegen

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Default for Codegen

fn default() -> Codegen

Returns the “default value” for a type.