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?