feat: make stl.h list|set|map_caster more user friendly.

include/pybind11/stl.h

@@ -166,13 +166,38 @@ struct list_caster {
     using value_conv = make_caster<Value>;
 
     bool load(handle src, bool convert) {
-        if (!isinstance<sequence>(src) || isinstance<bytes>(src) || isinstance<str>(src)) {
+        if (isinstance<bytes>(src) || isinstance<str>(src)) {
             return false;
         }
-        auto s = reinterpret_borrow<sequence>(src);
+        if (isinstance<sequence>(src)) {
+            return convert_elements(src, convert);
+        }
+        if (!convert) {
+            return false;
+        }
+        if (PyGen_Check(src.ptr())) {
+            // Designed to be behavior-equivalent to passing tuple(src) from Python:
+            // The conversion to a tuple will first exhaust the generator object, to ensure that
+            // the generator is not left in an unpredictable (to the caller) partially-consumed
+            // state.
+            assert(isinstance<iterable>(src));
+            return convert_elements(tuple(reinterpret_borrow<iterable>(src)), convert);
+        }
+        return false;
+    }
+
+private:
+    template <typename T = Type, enable_if_t<has_reserve_method<T>::value, int> = 0>
+    void reserve_maybe(const sequence &s, Type *) {
+        value.reserve(s.size());
+    }
+    void reserve_maybe(const sequence &, void *) {}
+
+    bool convert_elements(handle seq, bool convert) {
+        auto s = reinterpret_borrow<sequence>(seq);
         value.clear();
         reserve_maybe(s, &value);
-        for (auto it : s) {
+        for (auto it : seq) {
             value_conv conv;
             if (!conv.load(it, convert)) {
                 return false;
@@ -182,13 +207,6 @@ struct list_caster {
         return true;
     }
 
-private:
-    template <typename T = Type, enable_if_t<has_reserve_method<T>::value, int> = 0>
-    void reserve_maybe(const sequence &s, Type *) {
-        value.reserve(s.size());
-    }
-    void reserve_maybe(const sequence &, void *) {}
-
 public:
     template <typename T>
     static handle cast(T &&src, return_value_policy policy, handle parent) {

tests/test_stl.cpp

@@ -548,4 +548,7 @@ TEST_SUBMODULE(stl, m) {
         []() { return new std::vector<bool>(4513); },
         // Without explicitly specifying `take_ownership`, this function leaks.
         py::return_value_policy::take_ownership);
+
+    m.def("pass_std_vector_int", [](const std::vector<int> &vec_int) { return vec_int.size(); });
+    m.def("pass_std_set_int", [](const std::set<int> &set_int) { return set_int.size(); });
 }

tests/test_stl.py

@@ -379,3 +379,41 @@ def test_return_vector_bool_raw_ptr():
     v = m.return_vector_bool_raw_ptr()
     assert isinstance(v, list)
     assert len(v) == 4513
+
+
+def test_pass_std_vector_int():
+    fn = m.pass_std_vector_int
+    assert fn([1, 2]) == 2
+    assert fn((1, 2)) == 2
+    assert fn(i for i in range(3)) == 3
+    with pytest.raises(TypeError):
+        fn(set())
+    with pytest.raises(TypeError):
+        fn({})
+    with pytest.raises(TypeError):
+        fn({}.keys())
+
+
+def test_pass_std_set_int():
+    fn = m.pass_std_set_int
+    assert fn({1, 2}) == 2
+    with pytest.raises(TypeError):
+        fn([1, 2])
+    with pytest.raises(TypeError):
+        fn((1, 2))
+    with pytest.raises(TypeError):
+        fn({})
+    with pytest.raises(TypeError):
+        fn({}.keys())
+    with pytest.raises(TypeError):
+        fn(i for i in range(3))
+
+
+def test_list_caster_fully_consumes_generator_object():
+    def gen_mix():
+        yield from [1, 2.0, 3]
+
+    gen_obj = gen_mix()
+    with pytest.raises(TypeError):
+        m.pass_std_vector_int(gen_obj)
+    assert not tuple(gen_obj)