Keyword arguments mismatch with C++ function arguments

[uentity]

I have a C++ function with the following signature:

spv_float well_path_ident(
	ulong nx, ulong ny, spv_float coord, spv_float zcorn,
	spv_float well_info, bool include_well_nodes, const char* strat_traits = "online_tops",
	const ulong min_split_threshold = 0, spv_ulong hit_idx = nullptr
);

Here ulong is std::size_t, and spv_float, spv_ulong are std::shared_ptr pointers to my custom array type which is inherited from pybind11::array_t. I've written custom converters for it that are very similar to Eigen binding code. Converters are working as expected in my tests.

Next, I export the function above with the following snippet:

m.def("well_path_ident", &well_path_ident,
	"nx"_a, "ny"_a, "coord"_a, "zcorn"_a, "well_info"_a, "include_well_nodes"_a = true,
	"mesh_traits"_a = "online_tops", "min_split_threshold"_a = 0, "hit_idx"_a = nullptr
);

Everything compiles just fine! pybind11 correctly counts arguments of well_path_ident -- if I make a mistake (for ex. forget one argument) it will notify me with an error at compile time.

But after module is loaded in Python here's what I get with help(my_module) command:

well_path_ident(...)
        well_path_ident(*args, **kwargs)
        Overloaded function.

        1. well_path_ident(nx: int, ny: int, numpy.ndarray[float64], numpy.ndarray[float64], numpy.ndarray[float64], coord: bool, zcorn: unicode, well_info: int, numpy.ndarray[uint64]) -> numpy.ndarray[float64]

(I have one more overload of this function, but it has the same issue).

As you can see, keyword arguments "skip" numpy.ndarray[float64] (spv_float) for some reason, and starting from "coord" they bind to wrong C++ function arguments.

I feel that this is related in some way to custom type conversion code, but what really can cause such issue?
Btw, when I try to call this function from Python, I get an exception:

RuntimeError: Unknown internal error occurred

And actual C++ function isn't called, I can't get into it in debugger.

[uentity]

If I leave only one overload and remove all keyword arguments like this:

m.def("well_path_ident", &well_path_ident);

then function called properly without exceptions and all arguments are passed correctly.

[jagerman]

The issue is most likely stemming from inheriting from array_t while simultaneously using a std::shared_ptr around it. array_t (and object and all the other Python type wrappers) are already a "shared pointer" of a sort (though they are sharable references to Python-side numpy arrays rather than C++ types).

You probably want to use composition (i.e. use a local array_trather than inherit from it) instead.

I'll add a static_assert to catch this in the future.

[jagerman]

(I also couldn't reproduce the skipping-kwargs issue with regular array_t arguments, so I suspect it's the same issue).

[uentity]

I understand your point about all wrapped Python types being already reference counted via object. And I think I can switch from inheritance to composition and probably have this issue solved.

But still, if used properly, inheritance from object combined with std::shared_ptr holder is not such a nasty bad unacceptable thing. If it is, then it should be prohibited completely. If not, at least it shouldn't break pybind11 internals. IMHO.

[jagerman]

Yes, you're definitely right. That's what #786 will fix (by making it a compilation failure).

[jagerman]

Thanks for the report. This should cause a compilation failure now rather than an internal error. I've filed #787 separately to track properly supporting holders around converting types.

[jagerman]

I've reproduced the issue with this test case; investigating it now:

#include <pybind11/pybind11.h>

struct mytype {};
using mysp = std::shared_ptr<mytype>;

NAMESPACE_BEGIN(pybind11)
NAMESPACE_BEGIN(detail)

template <> struct type_caster<mysp> {
public:
	bool load(handle src, bool convert) { return false; }
	static handle cast(const mysp&, return_value_policy, handle) { return handle(); }
    operator mysp() { return value; }
	template <typename> using cast_op_type = mysp;
    static PYBIND11_DESCR name() { return _("foo"); }

private:
    mysp value;
};

NAMESPACE_END(detail)
NAMESPACE_END(pybind11)

namespace py = pybind11;
PYBIND11_PLUGIN(example)
{
   py::module m("example");
   m.def("f", [](int, mysp, int) {}, py::arg("a"), py::arg("b"), py::arg("c") = 2);
   return m.ptr();
}

[jagerman]

... which gives the rather interesting (and wrong) docstring:

python3 -c 'import example; print(example.f.__doc__);'
f(a: int, foo, b: int) -> c: None=2

[uentity]

Yes, that's exactly what I've got.