How to get instance of sub/child class at runtime?

[MatthiasKohl]

If I have a method which returns a pointer to parent type, it looks like with pybind, I can use the actual runtime (parent or child) type for methods/functions on that instance.

OTOH, in nanobind, probably because there is no holder pointer, but an instance of the type in the python object, I can't use the runtime-specific methods/functions on the instance.

Is there a way to work around this in general ? Or do I have to make sure that all functions return the actual type, which would mean that I'd have to know ahead of time what type to expect (in python) ?

[MatthiasKohl]

One way I could imagine this is to check for the type inside a wrapper function, have that wrapper function return a nb::object and do the cast manually depending on the runtime type.

Does this make sense ? Is there an easier way to do this automatically?

[wjakob]

Can you paste a reproducer here to explain the issue more specifically?

[MatthiasKohl]

So imagine we have this structure in C++ and we want to wrap the functions make_parent and print_stuff overloads:

struct Parent { ... };
struct Child : struct Parent { ... };

Parent* make_parent(bool child) {
  if (child)
    return new Child();
  return new Parent();
}

void print_stuff(Parent& p) { printf("this is a parent\n"); }
void print_stuff(Child& c) { printf("this is a parent\n"); }

If we bind those classes and functions in a straightforward way using nanobind, then call make_parent(True) from python, and then call print_stuff on the result, we'll get "this is a parent".
In pybind, we would get "this is a child" AFAIU

[MatthiasKohl]

sorry for the weird looking code, I wasn't able to come up with something short which shows the issue.

But I hope you get the point: make_parent basically transforms the return to a python type which simply stores an instance of Parent within it, AFAIU. This means we lose information about the runtime type.

I was able to do this instead:

nb::object make_parent(bool child) {
  if (child)
    return nb::cast(new Child());
  return nb::cast(new Parent());
}

and this works as intended, because now the python type actually holds the expected instance

[wjakob]

Right! This is a case where pybind11 and nanobind behave differently. pybind11 would potentially return a type that was different from the interface by peeking inside via RTTI at runtime.

I've grown increasingly less fond of this feature over the years. First of all, it's a weird deviation from the stated function interface which lists a return value of type Parent. The feature is also fragile. For example, if you had another class GrandChild deriving from Child with no explicit python bindings, then pybind11 would instead return it as a Parent.

A more consistent behavior is to match the function interface and support dynamic signatures using the sort of approach you mentioned.

[wjakob]

There is, btw, also the nanobind low-level instance interface: https://github.com/wjakob/nanobind/blob/master/docs/lowlevel.md.

This is a more dynamic approach that keeps you from having to declare potentially large numbers of nb::cast functions (which are template functions). Instead, you could lookup the desired output Python type and create the instance with that interface. (Potentially even involving indexing into a large array of types)

nb::object make_parent(bool child) {
   Parent *inst = some_process_which_creates_a_parent_instance();
   nb::object py_inst = nb::inst_wrap(inst->is_child() ? child_type : parent_type, inst);
   nb::inst_mark_ready(py_inst);
   return py_inst;
}