Default value for pybind11::function

[porrashuang]

Hi,
Previously (v2.2) I could use py::function func = py::none() to initialize/restore a function to null state.
Now latest pybind disallows function to become None, such above will hit assert in pytypes.h
what(): Object of type 'NoneType' is not an instance of 'function'

I can do py::function func = py::object() instead, but func.is_none() still returns false when I need to judge.
Since Python can allow functions to be reassigned with None, I'm not sure why it's disallowed in pybind, and is there a way to judge if a py::function is in default?

Related topics: #2986 #2701
Thanks.

[jiwaszki]

One solution I have found is to combine std::optional and std::variant capabilities from C++17.

First you need to define your class:

#include <pybind11/pybind11.h>
#include <pybind11/stl.h>

namespace py = pybind11;

class Foo
{
public:
    Foo(py::function _function) : func(_function)
    {
    }

    Foo(py::none _none) : func(_none)
    {
    }

    std::variant<py::function, py::none> func;
};

And provide bindings that will utilise these features:

py::class_<Foo, std::shared_ptr<Foo>> cls(module, "Foo");

cls.def(py::init([](std::optional<py::function> &func)
                    {
                        if (func.has_value())
                        {
                            return Foo(func.value());
                        }
                        return Foo(py::none());
                    }),
        py::arg("func").none(true) = py::none());

cls.def(
    "call_me", [](Foo &self)
    {
        if (std::holds_alternative<py::none>(self.func))
        {
            py::print("Function is None!");
            return;
        }
        std::get<py::function>(self.func)();
        return;
    });

cls.def_property(
    "func", [](Foo &self)
    {
        return self.func;
    },
    [](Foo &self, std::variant<py::function, py::none> &other)
    {
        self.func = other;
    });

If you try out this module it achieves your use-case goals (hopefully:)):

>>> import mymodule
>>> 
>>> def bar():
...     print("Welcome to the bar!")
... 
>>> a = mymodule.Foo()
>>> a.call_me()
Function is None!
>>> print(a.func)
None
>>> b = mymodule.Foo(bar)
>>> b.call_me()
Welcome to the bar!
>>> print(b.func)
<function bar at ...>
>>> b.func = None
>>> print(b.func)
None

In fact there could be a better solution but this one came to my mind first, I would be very happy to see more compact way of achieving it. As this one works for py::function/none only, you can always replace py::none in Foo class with py::object and do some extra work with std::get and calling is_none() on it if you feel like it. However in my opinion reducing possible arguments to actual functions and None is better overall.

Hope you find this answer satisfying!

[porrashuang]

To set it to back an invalid state(nullptr), one can use func.release() to reset. Also when py::function is default constructed, it's also in an invalid(nullptr) rather than None state.
According to https://pybind11.readthedocs.io/en/stable/advanced/pycpp/object.html?highlight=%22static_cast%3Cbool%3E%22#default-constructed-wrappers.