Macro create_init_submodule 

macro_rules! create_init_submodule {
    (
        $(#[$meta:meta])*
        $(classes: [ $($class: ty),+ ],)?
        $(complex_enums: [ $($complex_enum: ty),+ ],)?
        $(consts: [ $($const: ident),+ ],)?
        $(errors: [ $($error: ty),+ ],)?
        $(funcs: [ $($func: path),+ ],)?
        $(submodules: [ $($mod_name: literal: $init_submod: path),+ ],)?
    ) => { ... };
}

Create a crate-private function init_submodule to set up this submodule and call the same function on child modules (which should also use this macro).

This generates boilerplate for exposing classes, exceptions, functions, and child modules to the Python runtime, including a hack to allow importing from submodules, i.e.:

from foo.bar import baz

Example

use rigetti_pyo3::{create_init_submodule, exception, create_exception};
use rigetti_pyo3::pyo3::{prelude::*, exceptions::PyIOError};

#[pyfunction]
fn do_nothing() {}

#[pyclass]
struct CoolString(String);

#[derive(Debug, thiserror::Error)]
#[error("io error: {0}")]
struct RustIOError(#[from] std::io::Error);

exception!(RustIOError, "example", IOError, PyIOError, "IO Error");

mod my_submodule {
    use rigetti_pyo3::create_init_submodule;
    use rigetti_pyo3::pyo3::pyclass;

    #[pyclass]
    struct CoolInt(i32);

    create_init_submodule! {
        classes: [ CoolInt ],
    }
}

create_init_submodule! {
    /// Initialize this module and all its submodules
    classes: [ CoolString ],
    errors: [ IOError ],
    funcs: [ do_nothing ],
    submodules: [ "my_submodule": my_submodule::init_submodule ],
}

#[pymodule]
fn example(py: Python<'_>, m: &Bound<'_, PyModule>) -> PyResult<()> {
    init_submodule("example", py, m)
}