Leak report when using shared_ptr member

[robquant]

I am exploring transitioning a project from pybind11 to nanobind. However, while porting I ran into a warning from the nanobind leak detector, that I don't understand.

Here is the minimal C++ example code:

#include <memory>

#include <nanobind/nanobind.h>
#include <nanobind/stl/shared_ptr.h>

namespace nb = nanobind;

struct A
{
    A(int a) : a(a) {}
    int a;
};

struct Owner
{
    Owner(std::shared_ptr<A> a) : a{a} {}
    std::shared_ptr<A> a;
};

NB_MODULE(my_ext, m)
{
    nb::class_<A>(m, "A")
        .def(nb::init<int>());

    nb::class_<Owner>(m, "owner")
        .def(nb::init<std::shared_ptr<A>>());
}

When ran like this

import my_ext

a = my_ext.A(3)
owner = my_ext.owner(a)

# Explicitly deleting the owner object gets rid of the nanobind leak warnings
#del owner

upon exit of the interpreter I get the following warnings:

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

I read the section in the manual about cyclic references but I don't think these apply here. Can I ignore the warnings because they only arise because owner is not yet deleted when the atexit functions are run?

[wjakob]

This can indeed be an issue in Python < 3.12 — the interpreter isn't always perfectly collecting variables in the top scope and REPL.

I've found this to be more of an issue in small snippets and REPL usage as opposed to larger programs, where the logic is generally contained in functions (which don't have that issue). You can disable that warning if it bothers you, see the docs.