Why isn't python-exposed boost::gregorian::date available everywhere? - python-3.x

Question

I exposed boost::gregorian::date with the following:
date_from_python_date{};
to_python_converter<date, date_to_python_date, true>{};
where date_to_python_date is a struct with the right convert function: it converts it to a python datetime.date.
Some c++ functions return date and calling them from python works.
At a later stage, I have a c++ class
class F {
/// ....
public:
boost::gregorian::date start;
};
which I register with:
class_<F, F*, bases<B>>("F")
.def_readwrite("start", &F::start, "FTD")
;
I do this after having python-registered date.
I then obtain an instance f of the F wrapper. But then, when I print
f.start
The error is:
No Python class registered for C++ class boost::gregorian::date

Answer 1

In short, the return policy used by def_readonly() and def_readwrite() will default to using return_internal_reference for user-defined class types (see make_getter()). This return policy will suppress the use of custom converters. To resolve this, replace def_readonly() and def_readwrite() with add_property(), providing a boost::python::return_value_policy with a type of boost::python::return_by_value.
Change:
namespace python = boost::python;
python::class_<F, F*, python::bases<B>>("F")
.def_readwrite("start", &F::start, "FTD")
;
to:
namespace python = boost::python;
python::class_<F, F*, python::bases<B>>("F")
.add_property("start",
python::make_getter(
&F::start, python::return_value_policy<python::return_by_value>()),
python::make_setter(
&F::start, python::return_value_policy<python::return_by_value>()),
"FTD")
;
Here is a complete example demonstrating this difference:
#include <boost/python.hpp>
/// Mocks...
// Mockup user defined type.
class spam {};
struct egg
{
spam spam;
};
// Mockup convert that converts spam into 'hello world' strings.
struct spam_converter
{
static PyObject* convert(const spam&)
{
namespace python = boost::python;
python::str result("hello world");
return python::incref(result.ptr());
}
};
BOOST_PYTHON_MODULE(example)
{
namespace python = boost::python;
// Enable spam to string converter.
python::to_python_converter<spam, spam_converter>();
// Expose egg.
python::class_<egg>("Egg")
// Expose egg::spam as spam1, access will fail to find converter.
.def_readonly("spam1", &egg::spam)
// Expose egg::spam as spam2, automatic conveter will be found.
.add_property("spam2",
python::make_getter(
&egg::spam, python::return_value_policy<python::return_by_value>()))
;
}
Interactive usage:
>>> import example
>>> egg = example.Egg()
>>> try:
... spam = egg.spam1 # expect to throw
... assert(False)
... except TypeError:
... assert(True)
...
>>> spam = egg.spam2
>>> assert(spam == "hello world")
Note that although the same egg::spam data-member instance was being exposed as Egg.spam1 and Egg.spam2, the manner in which the data-member was being exposed affected whether or not the automatic converter was found during dispatch.