Added support for Mapping, Set and Sequence derived from collections.abc.

Author: timohl

include/pybind11/stl.h

@@ -173,7 +173,14 @@ struct set_caster {
 public:
     bool load(handle src, bool convert) {
         if (!PyObjectTypeIsConvertibleToStdSet(src.ptr())) {
-            return false;
+            if (!convert) {
+                return false;
+            }
+            if (!(isinstance(src, module_::import("collections.abc").attr("Set"))
+                  && hasattr(src, "__contains__") && hasattr(src, "__iter__")
+                  && hasattr(src, "__len__"))) {
+                return false;
+            }
         }
         if (isinstance<anyset>(src)) {
             value.clear();
@@ -237,7 +244,14 @@ struct map_caster {
 public:
     bool load(handle src, bool convert) {
         if (!PyObjectTypeIsConvertibleToStdMap(src.ptr())) {
-            return false;
+            if (!convert) {
+                return false;
+            }
+            if (!(isinstance(src, module_::import("collections.abc").attr("Mapping"))
+                  && hasattr(src, "__getitem__") && hasattr(src, "__iter__")
+                  && hasattr(src, "__len__"))) {
+                return false;
+            }
         }
         if (isinstance<dict>(src)) {
             return convert_elements(reinterpret_borrow<dict>(src), convert);

tests/test_stl.cpp

@@ -648,4 +648,7 @@ TEST_SUBMODULE(stl, m) {
         }
         return zum;
     });
+    m.def("roundtrip_std_vector_int", [](const std::vector<int> &v) { return v; });
+    m.def("roundtrip_std_map_str_int", [](const std::map<std::string, int> &m) { return m; });
+    m.def("roundtrip_std_set_int", [](const std::set<int> &s) { return s; });
 }

tests/test_stl.py

@@ -576,3 +576,129 @@ def gen_invalid():
     with pytest.raises(expected_exception):
         m.pass_std_map_int(FakePyMappingGenObj(gen_obj))
     assert not tuple(gen_obj)
+
+
+def test_sequence_caster_protocol(doc):
+    from collections.abc import Sequence
+
+    class SequenceLike(Sequence):
+        def __init__(self, *args):
+            self.data = tuple(args)
+
+        def __len__(self):
+            return len(self.data)
+
+        def __getitem__(self, index):
+            return self.data[index]
+
+    class FakeSequenceLike:
+        def __init__(self, *args):
+            self.data = tuple(args)
+
+        def __len__(self):
+            return len(self.data)
+
+        def __getitem__(self, index):
+            return self.data[index]
+
+    assert (
+        doc(m.roundtrip_std_vector_int)
+        == "roundtrip_std_vector_int(arg0: collections.abc.Sequence[int]) -> list[int]"
+    )
+    assert m.roundtrip_std_vector_int([1, 2, 3]) == [1, 2, 3]
+    assert m.roundtrip_std_vector_int((1, 2, 3)) == [1, 2, 3]
+    assert m.roundtrip_std_vector_int(SequenceLike(1, 2, 3)) == [1, 2, 3]
+    assert m.roundtrip_std_vector_int(FakeSequenceLike(1, 2, 3)) == [1, 2, 3]
+    assert m.roundtrip_std_vector_int([]) == []
+    assert m.roundtrip_std_vector_int(()) == []
+    assert m.roundtrip_std_vector_int(FakeSequenceLike()) == []
+
+
+def test_mapping_caster_protocol(doc):
+    from collections.abc import Mapping
+
+    class MappingLike(Mapping):
+        def __init__(self, **kwargs):
+            self.data = dict(kwargs)
+
+        def __len__(self):
+            return len(self.data)
+
+        def __getitem__(self, key):
+            return self.data[key]
+
+        def __iter__(self):
+            yield from self.data
+
+    class FakeMappingLike:
+        def __init__(self, **kwargs):
+            self.data = dict(kwargs)
+
+        def __len__(self):
+            return len(self.data)
+
+        def __getitem__(self, key):
+            return self.data[key]
+
+        def __iter__(self):
+            yield from self.data
+
+    assert (
+        doc(m.roundtrip_std_map_str_int)
+        == "roundtrip_std_map_str_int(arg0: collections.abc.Mapping[str, int]) -> dict[str, int]"
+    )
+    assert m.roundtrip_std_map_str_int({"a": 1, "b": 2, "c": 3}) == {
+        "a": 1,
+        "b": 2,
+        "c": 3,
+    }
+    assert m.roundtrip_std_map_str_int(MappingLike(a=1, b=2, c=3)) == {
+        "a": 1,
+        "b": 2,
+        "c": 3,
+    }
+    assert m.roundtrip_std_map_str_int({}) == {}
+    assert m.roundtrip_std_map_str_int(MappingLike()) == {}
+    with pytest.raises(TypeError):
+        m.roundtrip_std_map_str_int(FakeMappingLike(a=1, b=2, c=3))
+
+
+def test_set_caster_protocol(doc):
+    from collections.abc import Set
+
+    class SetLike(Set):
+        def __init__(self, *args):
+            self.data = set(args)
+
+        def __len__(self):
+            return len(self.data)
+
+        def __contains__(self, item):
+            return item in self.data
+
+        def __iter__(self):
+            yield from self.data
+
+    class FakeSetLike:
+        def __init__(self, *args):
+            self.data = set(args)
+
+        def __len__(self):
+            return len(self.data)
+
+        def __contains__(self, item):
+            return item in self.data
+
+        def __iter__(self):
+            yield from self.data
+
+    assert (
+        doc(m.roundtrip_std_set_int)
+        == "roundtrip_std_set_int(arg0: collections.abc.Set[int]) -> set[int]"
+    )
+    assert m.roundtrip_std_set_int({1, 2, 3}) == {1, 2, 3}
+    assert m.roundtrip_std_set_int(SetLike(1, 2, 3)) == {1, 2, 3}
+    assert m.roundtrip_std_set_int(set()) == set()
+    assert m.roundtrip_std_set_int(SetLike()) == set()
+    with pytest.raises(TypeError):
+        m.roundtrip_std_set_int(FakeSetLike(1, 2, 3))