Macro rigetti_pyo3::create_init_submodule

macro_rules! create_init_submodule {
    (
        $(classes: [ $($class: 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::{py_wrap_type, py_wrap_error, wrap_error, create_init_submodule};
use rigetti_pyo3::pyo3::{pyfunction, pymodule, Python, PyResult, types::PyModule};
use rigetti_pyo3::pyo3::exceptions::PyRuntimeError;

#[pyfunction]
fn do_nothing() {}

py_wrap_type! {
    PyCoolString(String) as "CoolString";
}

wrap_error!{
    RustIOError(std::io::Error);
}

py_wrap_error!(errors, RustIOError, IOError, PyRuntimeError);

mod my_submodule {
    use rigetti_pyo3::{py_wrap_type, create_init_submodule};
     
    py_wrap_type! {
        PyCoolInt(i32) as "CoolInt";
    }

    create_init_submodule! {
        classes: [ PyCoolInt ],
    }
}

create_init_submodule! {
    classes: [ PyCoolString ],
    errors: [ IOError ],
    funcs: [ do_nothing ],
    submodules: [ "my_submodule": my_submodule::init_submodule ],
}

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