Overriding virtual functions of abstract class in Python

[huangweiwu]

In the example of Overriding virtual functions in Python in the nanobind document.
What if class Dog is an abstract class? Dog Can't be binded directly since it has no construtor. We need to declare a Wrapper class like DogWrapper first.
In this case, my_ext.alarm will raise an type error that dog can't be converted to class Dog. How can I solve this problem?
The implicitly_convertible can't solve this problem.

class Dog {
public:
    virtual std::string bark() const = 0;
    std::string name;
};
class DogWrapper: class Dog
{
    DogWrapper();
    virtual std::string bark() const { return name + ": woof!"; }
};
struct PyDog : DogWrapper {
    NB_TRAMPOLINE(DogWrapper, 1);

    std::string bark() const override {
        NB_OVERRIDE(bark);
    }
};
void alarm(Dog *dog, size_t count = 3) {
    for (size_t i = 0; i < count; ++i)
        std::cout << dog->bark() << std::endl;
}
NB_MODULE(my_ext, m) {
  nb::class_<DogWrapper, PyDog>(m, "Dog")
         .def(nb::init<const std::string &>())
         .def("bark", &DogWrapper::bark)
  nb::implicitly_convertible<DogWrapper, Dog>();
  m.def("alarm", &alarm, "dog"_a, "count"_a = 3);
}


class ShihTzu(my_ext.DogWrapper):
    def bark(self):
        return self.name + ": yip!"
dog = ShihTzu("Mr. Fluffles")
my_ext.alarm(dog)

[wjakob]

Can you not declare the constructor in PyDog (i.e. not have this extra DogWrapper class?). nanobind also allows defining override for pure virtual base methods.

[huangweiwu]

If I dont declare DogWrapper, I can't bind init method for class Dog because Dog is an abstract class. In this case, python class ShihTzu can't be used to generate python object.
Although I can add an init method for class ShihTzu, the python object dog can't converted to C++ Class Dog when calling alarm.
The Class Dog is an abstract class. That's my key problem.

[wjakob]

This works fine for me:

class Dog {
public:
    virtual std::string bark() const = 0;
    virtual ~Dog() = default;
    std::string name;
};

struct PyDog : Dog {
    NB_TRAMPOLINE(Dog, 1);

    PyDog() { }
    std::string bark() const override {
        NB_OVERRIDE_PURE(bark);
    }
};

void myalarm(Dog *dog, size_t count = 3) {
    for (size_t i = 0; i < count; ++i)
        std::cout << dog->bark() << std::endl;
}

NB_MODULE(my_ext, m) {
    nb::class_<Dog, PyDog>(m, "Dog")
        .def(nb::init<>())
        .def("bark", &Dog::bark);
    m.def("alarm", &alarm, "dog"_a, "count"_a = 3);
}

import my_ext

class ShihTzu(my_ext.alarm.Dog):
    def __init__(self, name):
        super().__init__()
        self.name = name

    def bark(self):
        return self.name + ": yip!"
dog = ShihTzu("Mr. Fluffles")
my_ext.alarm(dog)

[huangweiwu]

Nice. Add a constructor for the Py*** Class can solve this problem.