Implicit conversion from kwargs using a type_caster

[thelfer]

Dear nanobind community,

I am a new nanobind user. The C++ library I want to wrap uses a custom type named Parameters as the main argument of most of its functions. This type is basically the C++ counterpart of a dict (except that the keys are strings).

I already implemented a type_caster which allows on the fly conversions between a Parameters and a dict. This works fine. I can wrap a function f and pass it a dict:

f({"test": 12})

However, as my library uses this type everywhere, I would like to add some syntaxic sugar to my python bindings and allow the following syntax:

f(test =  12)

My idea was to modify my type_caster class to allow conversion from a kwarg. This is the current implementation of the from_python method:

bool type_caster<manta::Parameters>::from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept
{
  if (!isinstance<dict>(src)) {
    return false;
  }
  auto d       = steal<dict>(src);
  this->value_ = manta::Parameters{};
  for (const auto [k, v] : d) {
    if (!isinstance<str>(k)) {
      return false;
    }
    const auto cv = variadic_caster(v, flags, cleanup);
    if (!cv.first) {
      return false;
    }
    this->value_.insert(str(k).c_str(), cv.second);
  }
  return true;
}

As a first try, I just changed the first test:

  if ((!isinstance<dict>(src))&&(!isinstance<kwargs>(src))) {
    return false;
  }

but that did not seem to work, at least in the case of constructor taking a const reference to a Parameters. The error message is:

$ python3 test.py 
Traceback (most recent call last):
  File "/home/th202608/codes/pymanta/master/install/test.py", line 2, in <module>
    ps = manta.PhysicalSystem(mesh = {"generator": "Grid",
TypeError: __init__(): incompatible function arguments. The following argument types are supported:
    1. __init__(self) -> None
    2. __init__(self, arg: Parameters, /) -> None

Invoked with types: manta.PhysicalSystem, kwargs = { mesh: dict, geometricHypothesis: str }

Can anyone help me ?

[thelfer]

It seems that kwargs are treated in a specific way by nanobind and that the type_caster<Parameters>::from_python is not called with a kwargs argument.

A solution would be to create a thin wrapper that takes a kwargs object, converts it to a Parameter and then call the initial function. That seems a reasonnable solution, but I did not see in the documentation how to use the class type_caster directly.

In particular, I have no idea of what to give to the flag and cleanup arguments.

Any help ?

[thelfer]

In particular, I have no idea of what to give to the flag and cleanup arguments.

Ok, it seems that using 0 and nullptr does the trick.

For the moment, I'll go with the solution of creating a wrapper to the nanobind::def function that will declare two overloaded versions of each function: one using the Parameters class and one using a kwargs.

If anyone has a comment on this post, do not hesitate to improve this solution.