Assign a derived instance to a base shared_ptr

[j-faria]

Hi!
I'm trying to use nanobind to expose a class that holds shared pointers to a base class. I would like to expose the shared pointer as a property and be able to assign any derived object from within Python. Here's an example, missing the setter:

#include <memory>

#include <nanobind/nanobind.h>
#include <nanobind/stl/shared_ptr.h>
namespace nb = nanobind;


struct Base {
    virtual double fun(double a) = 0;
};

struct Derived1 : Base {
    double fun(double a) { return a; }
};

struct Derived2 : Base {
    double fun(double a) { return 2 * a; }
};

struct User {
    std::shared_ptr<Base> b;
    User() {
        b = std::make_shared<Derived1>();
    }
};


NB_MODULE(myext, m)
{
    nb::class_<Base>(m, "Base");
    nb::class_<Derived1>(m, "Derived1")
        .def(nb::init<>());
    nb::class_<Derived2>(m, "Derived2")
        .def(nb::init<>());
    nb::class_<User>(m, "User")
        .def(nb::init<>())
        .def_prop_rw("b",
            [](User &u) { return u.b ; },
            [](User &u, /* what argument here? */) { /* how to assign to u.b ? */ });
}

On the Python side, I would like to do something like

from myext import Derived1, Derived2, User

u = User()

print(u.b) # works: prints <myext.Derived1 object at ...>

d2 = Derived2()
u.b = d2  # fails

Is something like this possible?

[wjakob]

I don't see directly what the problem is. What happens when you bind a setter for std::shared_ptr<Base>? Note that you must likely bind .def(nb::init<>()) for Base so that the Python-derived object can call the parent class constructor.

[j-faria]

With this setter

nb::class_<User>(m, "User")
    .def(nb::init<>())
    .def_prop_rw("b",
        [](User &u) { return u.b ; },
        [](User &u, std::shared_ptr<Base> b) { u.b = b; });

I get the following error on the Python side

u.b = d2
E   TypeError: (): incompatible function arguments. The following argument types are supported:
E       1. (self, arg: myext.Base, /) -> None
E   
E   Invoked with types: myext.User, myext.Derived2

Note that you must likely bind .def(nb::init<>()) for Base so that the Python-derived object can call the parent class constructor.

Not sure I can because the Base class is abstract.

[j-faria]

I was able to make it work by specifying the base class of Derived1 and Derived2

NB_MODULE(myext, m)
{
    nb::class_<Base>(m, "Base");
    nb::class_<Derived1, Base>(m, "Derived1")
        .def(nb::init<>());
    nb::class_<Derived2, Base>(m, "Derived2")
        .def(nb::init<>());
    nb::class_<User>(m, "User")
        .def(nb::init<>())
        .def_prop_rw("b",
            [](User &u) { return u.b ; },
            [](User &u, std::shared_ptr<Base> &b) { u.b = b; });
}

but now I'm getting some leak warnings:

nanobind: leaked 1 instances!
nanobind: leaked 2 types!
 - leaked type "myext.Base"
 - leaked type "myext.Derived2"
nanobind: leaked 1 functions!
 - leaked function "__init__"
nanobind: this is likely caused by a reference counting issue in the binding code.

[wjakob]

Do the leak warnings still occur if you explicitly del the local variables in your test script and run gc.collect()? Some older Python versions aren't that good at cleaning up cyclic references in a global scope.

If the issue persists, could you post the latest/complete version of your reproducer and Python script that drives it?

[wjakob]

ping?

[j-faria]

Sorry for the late reply. No, it seems that deleting the variables solves the leak warnings. Even without running gc.collect().