How to register a template based function with pybind11 class or module level function?

[Mayuresh16]

How to deal with such template-based functions or methods while registering them at class or module-level def?
I'm still confused about how should I deal with such problems especially while specifying the signature of a constructor with init<>()?

#include <pybind11/pybind11.h>
#include <thread>

namespace py = pybind11;

// Accepting one or more arguments
template <typename ...Args> 
int sum(Args&&... args){ 
    return (args + ...); 
}

PYBIND11_MODULE(mymodule, m){
	
	m.def("mysum", sum);
	
	py::class_<std::thread>(m, "Thread")
	/* Second Problem - 
	How do I specify this kind of scenario in the constructor( init<>() ) as well?
	
	template< class Function, class... Args >
	explicit thread( Function&& f, Args&&... args );
	
	*/
	.def(py::init<>());	// ???
}

I intentionally have used std::thread class constructor as an example for an easy understanding

• Error for m.def("mydef", sum);

try.cpp: In function ‘void pybind11_init_mymodule(pybind11::module_&)’:
try.cpp:18:14: error: no matching function for call to ‘pybind11::module_::def(const char [6], <unresolved overloaded function type>)’
	 18 |         m.def("mysum", sum);
		|         ~~~~~^~~~~~~~~~~~~~
In file included from try.cpp:1:
/home/kali/.local/lib/python3.9/site-packages/pybind11/include/pybind11/pybind11.h:1032:14: note: candidate: ‘template<class Func, class ... Extra> pybind11::module_& pybind11::module_::def(const char*, Func&&, const Extra& ...)’
1032 |     module_ &def(const char *name_, Func &&f, const Extra& ... extra) {
		|              ^~~
/home/kali/.local/lib/python3.9/site-packages/pybind11/include/pybind11/pybind11.h:1032:14: note:   template argument deduction/substitution failed:
try.cpp:18:14: note:   couldn’t deduce template parameter ‘Func’
	 18 |         m.def("mysum", sum);

Please let us know if you have any knowledge of this issue. @ALL @wjakob
Thank you!

P.S. - Despite the fact that PyBind11 is new to me, I've attempted a few non-template-based examples.

[jiwaszki]

Hi @Mayuresh16 ,

It is fairly simple:

    m.def("mysum", &maths::sum<int>);
    m.def("mysum", &maths::sum<int, int>);
    // ... and so on
    // Just for good measure:)
    m.def("mysum", &maths::sum<int, int, int, int, int, int, int, int, int>);

And later in Python you can just call:

mymodule.mysum(1)
>>> 1

mymodule.mysum(2, 3)
>>> 5

mymodule.mysum(1, 2, 3)) # won't work as there is no overload provided
>>> TypeError: mysum(): incompatible function arguments. The following argument types are supported:
>>>  1. (arg0: int) -> int
>>>  2. (arg0: int, arg1: int) -> int
>>>  3. (arg0: int, arg1: int, arg2: int, arg3: int, arg4: int, arg5: int, arg6: int, arg7: int, arg8: int) -> int

mymodule.mysum(1, 2, 3, 4, 5, 6, 7, 8, 9)
>>> 45

But it is impossible to bind variadic function with "unrestrained" number of arguments. Sadly without any compilation time information about number of arguments you won't be able to. However there is something called py::args which is able to help in some cases:

    m.def("mysum_with_args", [](py::args args)
          {
              int sum = 0;
              for (auto it : args)
              {
                  sum += it.cast<int>();
              }
              return sum;
          });

mymodule.mysum_with_args(2)
>>> 2

mymodule.mysum_with_args(2, 2, 2)
>>> 6

mymodule.mysum_with_args(2, 2, 2, 2, 2)
>>> 10

That is the best solution to my knowledge. You either use py::args and somehow translate C++ function to your lambda body or stick to known number/types of arguments. Same logic applies to mentioned init functions, bindings must match with existing constructors for the class.

Hope this helps!

[Mayuresh16]

Thank you @jiwaszki !