Changing default bound type of a property

[KerstinKeller]

We're currently trying to replace our handwritten Python bindings with nanobind for eCAL.
I have multiple question, but the first one is, how do I easily change the type of the property of the wrapped Python class.
Let's asume the following C++ class:

struct DataTypeInformation
{
  std::string name;          //!< name of the datatype
  std::string encoding;      //!< encoding of the datatype (e.g. protobuf, flatbuffers, capnproto)
  std::string descriptor;    //!< descriptor information of the datatype (necessary for reflection)
}

With this wrapping, the descriptor property will be of type str.

nb::class_<DataTypeInformation>(m, "DataTypeInformation")
  .def(nb::init<>())
  .def_rw("name", &DataTypeInformation::name)
  .def_rw("encoding", &DataTypeInformation::encoding)
  .def_rw("descriptor", &DataTypeInformation::descriptor)

What is the easiest way, and what are the options I have in general, so that the python type for the descriptor property is bytes?

[oremanj]

The easiest option is probably to use a def_visitor:

template <class T>
struct bytestring_property : nb::def_visitor<bytestring_property<T>> {
    bytestring_property(const char* name, std::string T::*mptr) : name(name), mptr(mptr) {}
    const char* name;
    std::string T::*mptr;
    
    template <typename Class, typename... Extra>
    void execute(Class &cl, const Extra&... extra) {
        cl.def_prop_rw(name,
                       [mptr=mptr](const T& self) { return nb::bytes((self.*mptr).c_str(), (self.*mptr).size()); },
                       [mptr=mptr](T& self, nb::bytes val) { (self.*mptr).assign(val.c_str(), val.size()); });
    }
};

nb::class_<DataTypeInformation>(m, "DataTypeInformation")
  .def(nb::init<>())
  .def(bytestring_property("name", &DataTypeInformation::name))
  .def(bytestring_property("encoding", &DataTypeInformation::encoding))
  .def(bytestring_property("descriptor", &DataTypeInformation::descriptor));

This is untested but you probably get the picture.

If every std::string in your bindings (or at least one particular compilation unit of them) should be treated as Python bytes, then you also have the option of omitting the nanobind/stl/string.h #include, and providing your own type caster for std::string that interoperates with Python bytes rather than str.

[KerstinKeller]

Thanks for your answer and sorry for getting back to you so late.

In the meantime I had found the following approach, which works, too.
Are these two approaches essentially the same, or do they behave differently?

  nb::class_<eCAL::SDataTypeInformation>(m, "DataTypeInformation")
    .def(nb::init<>())
    .def_rw("name", &eCAL::SDataTypeInformation::name)
    .def_rw("encoding", &eCAL::SDataTypeInformation::encoding)
    .def_prop_rw("descriptor",
        // Getter: convert std::string to nb::bytes
        [](const eCAL::SDataTypeInformation &self) -> nb::bytes {
            return nb::bytes(self.descriptor.c_str(), self.descriptor.size());
        },
        // Setter: convert nb::bytes back to std::string
        [](eCAL::SDataTypeInformation &self, nb::bytes b) {
            self.descriptor = std::string(b.c_str(), b.size());
        })

[oremanj]

Ah, I misread your original request and thought you wanted all of these properties to be bytes, or otherwise had a lot of them to define. The def_visitor is a tool for stamping out property definitions exactly like the one in your approach. If you only have a few of these properties, it's unlikely to be worth the abstraction trouble. If you have a lot, it might be helpful for avoiding duplication.

[KerstinKeller]

I will probably need it it multiple places, so understanding about the visitors is very helpful.
But if it's essentially the same, but visitors avoid boilerplate, then i can choose which one is appropriate on a case by case basis.
Thanks!