Is there a way that I can know the data is from implicit conversion?

[zhqrbitee]

Hi, currently I have a use case that an be simplified like below:

.// bind vector<double> to python as "VectorF"
bind_vector<std::vector<double>>(m, "VectorF");
// ...
cls.def set_value(T& self, std::vector<double>& vec) {
    self.vec = vec;
}

# in python, assign values from list
object.set_value([1.0, 2.0, 3.0, ...])

Nanobind can convert the list implicitly to VectorF and then get std::vector<double> from it (due to implicitly_convertible<iterable, Vector>() in bind_vector), so above codes run without problems. However, to make codes more efficient, I'd like to move the vector if it is implicitly created, something like below:

def set_value(T& self, pointer_and_handle<std::vector<double>> object) {
    if (is_implicitly_created(object.h)) { 
        self.vec = std::move(*object.p);
    } else {
        self.vec = *object.p;    // in case this vector if from `VectorF ` in python which owns the data.
    }
}

Is there any way I can achieve this?

[oremanj]

The h member of pointer_and_handle is stored before implicit conversions, so you can check its Python type:

if (inst_check(object.h) && type_info(object.h.type()) == typeid(std::vector<double>)) {
    self.vec = *object.p;
} else {
    self.vec = std::move(*object.p);
}

inst_check verifies whether the object is an instance of a type that was bound with nanobind, which is a prerequisite for using type_info.

On many platforms, the type equivalence check will do a string comparison. If everything is in the same Python extension module, you can do a pointer comparison instead (&type_info(object.h.type()) == &typeid(std::vector<double>)) to squeeze out an extra bit of performance, but this is not safe if the vector is bound in a different extension module than it is used.

[oremanj]

It may be easier to write two overloads of set_value and use noconvert for the argument to the first one. Then anything that requires an implicit conversion will skip the first overload and match the second.

cls.def("set_value", [](T& self, std::vector<double>& vec) { self.vec = vec; }, nb::arg().noconvert());
cls.def("set_value", [](T& self, std::vector<double>& vec) { self.vec = std::move(vec); });