Finalization of non-constant static references to python objects

[apple1417]

After recently updating, I played around with py::gil_safe_call_once_and_store, and found it reasonably useful in avoiding the decref after finalization crash. However, it seems it does this by just having a leaking destructor. This is fine for a constant static reference, like in the stated example, but it's not so suitable for a more temporary reference which might get swapped out.

To explain further, a situation I've run into a lot is having C++ run Python callbacks out of band. A simplified example for console commands might look like:

static std::unordered_map<std::string, py::object> console_commands{};

void on_console_command(const std::string& cmd, const std::string& args) {
    const py::gil_scoped_acquire gil{};
    console_commands[cmd](args);
}

...

m.def("add_console_command", [](const std::string& cmd, const py::object& callback) {
    console_commands.emplace(cmd, callback);
});

m.def("remove_console_command", [](const std::string& cmd) {
     console_commands.erase(console_commands.find(cmd));
});

Assuming it still holds a callback when the process quits, this map has the exact same decref after finalization issue as a standard static reference. But it's also completely expected that I might delete elements from it at runtime, and I don't want those to leak.

Previously I was actually storing my own wrapper type, which did the following.

#if PY_VERSION_HEX >= 0x030D0000
#define PY_IS_FINALIZING() Py_IsFinalizing()
#else
#define PY_IS_FINALIZING() _Py_IsFinalizing()
#endif

StaticPyObject::~StaticPyObject() {
    auto handle = this->inner_obj.release();

    if (PY_IS_FINALIZING() != 0 || Py_IsInitialized() == 0) {
        return;
    }

    const py::gil_scoped_acquire gil{};
    if (handle) {
        handle.dec_ref();
    }
}

For now it's looking like I need to keep it around for these sorts of situations. Is there any chance of seeing an "official" solution?