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.