Looking for boilerplate reduction in my function binding code

[nurpax]

Hi!

I'm making Python bindings for ImGui and trying to find a way to bind some function arguments with less boilerplate.

I'm facing an enum pattern where enums are declared with normal C++ enums, but functions using the enum are in fact not using the enum type but rather an int typedef. Here's how the code looks like:

enum ImGuiButtonFlags_
{
    ImGuiButtonFlags_None                   = 0,
    ImGuiButtonFlags_MouseButtonLeft        = 1 << 0,
    ImGuiButtonFlags_MouseButtonRight       = 1 << 1,
    ImGuiButtonFlags_MouseButtonMiddle      = 1 << 2,
};

typedef int ImGuiButtonFlags;  // -> enum ImGuiButtonFlags_     // Flags: for InvisibleButton()

I can get the above translated into a Python IntFlag enum. This part is fine:

class ButtonFlags(enum.IntFlag):
    NONE = 0
    MOUSE_BUTTON_LEFT = 1
    MOUSE_BUTTON_RIGHT = 2
    MOUSE_BUTTON_MIDDLE = 4
    MOUSE_BUTTON_MASK_ = 7
    MOUSE_BUTTON_DEFAULT_ = 1

Here's how these types are used in ImGui:

bool ImGui::InvisibleButton(const char* str_id, const ImVec2& size_arg, ImGuiButtonFlags flags);

Note how the int typedef ImGuiButtonFlags is used, and not ImGuiButtonFlags_. Since flags is really just an int, Nanobind has no idea that flags is supposed to be typdef ButtonFlags.

This leads to a fair bit of boilerplate in InvisibleButton bindings definition:

m.def("invisible_button", [](const char* str_id, const ImVec2 &size, ImGuiButtonFlags_ flags) {
    return ImGui::InvisibleButton(str_id, size, flags);
}, "str_id"_a, "size"_a, "flags"_a.sig("ButtonFlags.NONE") = ImGuiButtonFlags_None);

# this produces the desired prototype in Python:
#
# def invisible_button(str_id: str, size: tuple[float, float], flags: ButtonFlags = ButtonFlags.NONE) -> bool: ...

This pattern is repeated many times over in the ImGui API.

I wonder if there's a better way to express this, without having to write those lambda wrappers for each API function that uses flags like above?

[oremanj]

I wonder if there's a better way to express this, without having to write those lambda wrappers for each API function that uses flags like above?

C++ template metaprogramming can't tell the difference between a typedef and the type that it expands to. If you can't change the underlying library to use a stronger type for these flags arguments, then it's sort of fundamentally impossible for nanobind to tell what's going on on its own.

C++ template metaprogramming also can't tell the argument names of a function, so any option that is less boilerplate-y would lose those in the bindings.

If the signatures for these functions are relatively consistent, such as if the flags argument is always the final one, you might be able to eliminate some of the boilerplate using a def_visitor: (example is untested)

template <class Flags, class Sig>
struct with_flags;

template <class Flags, class R, class... Args>
struct with_flags<Flags, R(Args..., int)> : nb::def_visitor<with_flags_impl<Flags, R(Args..., int)>> {
    with_flags_impl(const char* name, R (*fp)(Args..., int), Flags default_val, const char* default_repr)
      : name(name), fp(fp), default_val(default_val), default_repr(default_repr) {}
    const char* name;
    R (*fp)(Args..., int);
    Flags default_val;
    const char* default_repr;

    template <typename Class, typename... Extra>
    void execute(Class &cl, const Extra&... extra) {
        cl.def(name, [fp=fp](Args... args, Flags flags) -> R {
            return (*fp)(args..., flags);
        }, std::conditional_t<false, Args, nb::arg>()..., "flags"_a.sig(default_repr) = default_val, extra...);
    }
};

NB_MODULE(mymod, m) {
    m.def(with_flags("invisible_button", &ImGui::InvisibleButton, ImGuiButtonFlags_None, "ButtonFlags.NONE"));
}

I don't think I would personally find this to be worth the trouble unless you have, like, more than a hundred of these.

Less complicated option that would only work if you know on your platform's ABI that the int and the enum have the same calling convention:

template <class Flags, class R, class... Args>
auto with_flags(R (*fp)(Args..., int)) {
    return reinterpret_cast<R (*)(Args..., Flags)>(fp);
}

NB_MODULE(mymod, m) {
    m.def("invisible_button", with_flags(&ImGui::InvisibleButton),
          "str_id"_a, "size"_a, "flags"_a.sig("ButtonFlags.NONE") = ImGuiButtonFlags_None);
}

[nurpax]

Thanks for the reply! I agree and ended up going for just the simple solution of tolerating a bit of that boilerplate. It's not that much code after all.

For another API that I'm currently working on, I've chosen to generate the m.def code using Python.