Bindings for std::span

[Walter-Reactor]

Has there been any consideration to adding bindings for std::span or other span-like objects? I'm trying to write a binding and finding it's a challenge to juggle the lifetimes, and wondering if there's any prior art here. list_binding sadly doesn't seem to work well.

Going from python, it seems like there wouldn't be any real way to indicate that C++ owns the data without some kind of wrapper around the span object to free the refcount when the object is destroyed, and going from C++ seems even more dangerous unless you go through and immediately create castings/clones of every held object. Am I missing anything here?

[wjakob]

Nanobind is feature-scoped to C++17. It might make sense to develop some kind of C++20 (and beyond) extension layer, but I do not wish to have such functionality as part of this project.

[Walter-Reactor]

I had the same questions. I wound up with this which has so far worked with the very simple test cases I've thrown at it - It's a modified version of some bindings for abseil::Span I found

template <typename T>
    class type_caster<span<T>>
    {
        // The type referenced by the span, with const removed.
        using value_type = std::remove_cv_t<T>;
        // Avoid pitfalls with std::vector<bool>
        using ListCaster = list_caster<std::vector<std::conditional_t<std::is_same_v<bool, value_type>, uint8_t, value_type>>, value_type>;
        static_assert(sizeof(bool) == sizeof(uint8_t), "bool representation size is unexpected!");

        std::optional<ListCaster> list_caster;

    public:
        using Value = span<T>;
        Value value = span<T>(nullptr, 0);

        static constexpr auto Name = ListCaster::Name;

        // We do not allow moving because 1) spans are super lightweight, so there's
        // no advantage to moving and 2) the span cannot exist without the caster,
        // so moving leaves an implicit dependency (while a reference or pointer
        // make that dependency explicit).
        template <typename T_>
        using Cast = movable_cast_t<T_>;
        operator Value *() { return &value; }
        operator Value &() { return value; }

        // Cast Python -> C++ (nb::cast call)
        bool from_python(handle src, uint8_t flags, cleanup_list *cleanup) noexcept
        {
            uint8_t local_flags = flags_for_local_caster<T>(flags);

            // First try to convert from ndarray for efficiency
            // Try to get a 1D contiguous array directly using type tags
            if constexpr (is_ndarray_scalar_v<T>)
            {
                auto caster = make_caster<nb::ndarray<T, ndim<1>>>();
                if (caster.from_python(src, local_flags, cleanup))
                {
                    // Create a span from the array data
                    value = span<T>(caster.value.data(), caster.value.shape(0));
                    return true;
                }
            }

            // Attempt to convert a native sequence. If the is_base_of_v check passes,
            // the elements do not require converting and pointers do not reference a
            // temporary object owned by the element caster. Pointers to converted
            // types are not allowed because they would result a dangling reference
            // when the element caster is destroyed.
            if (std::is_const_v<T> &&
                (!std::is_pointer_v<T> || is_base_caster_v<make_caster<T>>))
            {
                list_caster.emplace();
                if (list_caster->from_python(src, local_flags, cleanup))
                {
                    // Reinterpret cast here is required to handle vector<bool>
                    value = span<T>(reinterpret_cast<T *>(list_caster->value.data()), list_caster->value.size());
                    return true;
                }
                else
                {
                    list_caster.reset();
                }
            }

            return false; // Python type cannot be loaded into a span.
        }

        // Cast C++ -> Python (when returning a span from a C++ function)
        static handle from_cpp(span<T> src, rv_policy policy, cleanup_list *cleanup)
        {
            return ListCaster::from_cpp(src, policy, cleanup);
        }
    };

[bethebunny]

Thanks for the start :) For from_cpp, it seems like rv_policy::reference_internal should be useful in safely covering cases where you want to return a view to data in a method. I'm trying to figure out if I can override the policy in the caster, or set a different default policy for spans.

Edit: actually basically what I want is close to make_iterator, but I'd want it to always nb::keep_alive on the parent object.

[Walter-Reactor]

Unfortunately the approach I was taking runs into issues if you have a std::optionalstd::span. The Caster may be constructed as part of another caster if you have a std::optional span or worse, a std::vector of span, so having the list_caster live for the duration of the main caster leads to dangling memory. Instead, I simply move the std::vector onto the heap, stick it in a capsule, and put it in the cleanup list. This seems to work in the testing I've done thus far, I'll post if I find any other problems.

[bethebunny]

Here's the janky thing I've landed on for now: https://gist.github.com/bethebunny/0d38b8cb45a3586c567b7f37d969c2b0 lots to improve but it is getting the job done for the time being :)

[Walter-Reactor]

ahh, that solution with specializing the outer type_caster is quite clever! I'm sticking with making the capsule store things for now since it's more general, though does lead to a bit of overhead.