stl_bind: apply py::local attribute by default

This applies the `py::local` attribute by default to `stl_bind` types.

Author: jagerman

include/pybind11/stl_bind.h

@@ -376,10 +376,10 @@ NAMESPACE_END(detail)
 // std::vector
 //
 template <typename Vector, typename holder_type = std::unique_ptr<Vector>, typename... Args>
-class_<Vector, holder_type> bind_vector(module &m, std::string const &name, Args&&... args) {
+class_<Vector, holder_type> bind_vector(handle scope, std::string const &name, Args&&... args) {
     using Class_ = class_<Vector, holder_type>;
 
-    Class_ cl(m, name.c_str(), std::forward<Args>(args)...);
+    Class_ cl(scope, name.c_str(), pybind11::local(), std::forward<Args>(args)...);
 
     // Declare the buffer interface if a buffer_protocol() is passed in
     detail::vector_buffer<Vector, Class_, Args...>(cl);
@@ -531,12 +531,12 @@ template <typename Map, typename Class_> auto map_if_insertion_operator(Class_ &
 NAMESPACE_END(detail)
 
 template <typename Map, typename holder_type = std::unique_ptr<Map>, typename... Args>
-class_<Map, holder_type> bind_map(module &m, const std::string &name, Args&&... args) {
+class_<Map, holder_type> bind_map(handle scope, const std::string &name, Args&&... args) {
     using KeyType = typename Map::key_type;
     using MappedType = typename Map::mapped_type;
     using Class_ = class_<Map, holder_type>;
 
-    Class_ cl(m, name.c_str(), std::forward<Args>(args)...);
+    Class_ cl(scope, name.c_str(), pybind11::local(), std::forward<Args>(args)...);
 
     cl.def(init<>());
 

tests/pybind11_local_bindings.cpp

@@ -32,4 +32,22 @@ PYBIND11_MODULE(pybind11_local_bindings, m) {
     m.def("register_nonlocal", [m]() {
         bind_local<NonLocalType, 0>(m, "NonLocalType");
     });
+
+    // test_stl_bind_local
+    // stl_bind.h binders defaults to py::local.  Note that the value doesn't have to be local, even
+    // if the overall container is:
+    py::bind_vector<std::vector<LocalType>>(m, "LocalVec");
+    py::bind_vector<std::vector<NonLocalType>>(m, "LocalVec2");
+    py::bind_map<std::unordered_map<std::string, LocalType>>(m, "LocalMap");
+    py::bind_map<std::unordered_map<std::string, NonLocalType>>(m, "LocalMap2");
+
+    // test_stl_bind_global
+    // stl_bind binders can, however, be overridden to global using `py::local(false)` (in which
+    // case this will fail):
+    m.def("register_nonlocal_stl1", [m]() {
+        py::bind_vector<std::vector<NonLocal2>>(m, "NonLocalVec", py::local(false));
+    });
+    m.def("register_nonlocal_stl2", [m]() {
+        py::bind_map<std::unordered_map<std::string, NonLocal2>>(m, "NonLocalMap", py::local(false));
+    });
 }

tests/test_local_bindings.cpp

@@ -42,4 +42,17 @@ TEST_SUBMODULE(local_bindings, m) {
         }
         else throw std::runtime_error("test_class not enabled");
     });
+
+    // test_stl_bind_local
+    // stl_bind.h binders defaults to py::local:
+    py::bind_vector<std::vector<LocalType>>(m, "LocalVec");
+    py::bind_vector<std::vector<NonLocalType>>(m, "LocalVec2");
+    py::bind_map<std::unordered_map<std::string, LocalType>>(m, "LocalMap");
+    py::bind_map<std::unordered_map<std::string, NonLocalType>>(m, "LocalMap2");
+
+    // test_stl_bind_global
+    // They can, however, be overridden to global using `py::local(false)`:
+    bind_local<NonLocal2, 10>(m, "NonLocal2");
+    py::bind_vector<std::vector<NonLocal2>>(m, "NonLocalVec", py::local(false));
+    py::bind_map<std::unordered_map<std::string, NonLocal2>>(m, "NonLocalMap", py::local(false));
 }

tests/test_local_bindings.py

@@ -50,3 +50,50 @@ def test_duplicate_local():
     assert str(excinfo.value) == (
         'generic_type: type "LocalExternal" is already registered!'
         if hasattr(pybind11_tests, 'class_') else 'test_class not enabled')
+
+
+def test_stl_bind_local():
+    import pybind11_local_bindings as m2
+
+    v1, v2 = m1.LocalVec(), m2.LocalVec()
+    v1.append(m1.LocalType(1))
+    v1.append(m1.LocalType(2))
+    v2.append(m2.LocalType(1))
+    v2.append(m2.LocalType(2))
+
+    with pytest.raises(TypeError):
+        v1.append(m2.LocalType(3))
+    with pytest.raises(TypeError):
+        v2.append(m1.LocalType(3))
+
+    assert [i.get() for i in v1] == [0, 1]
+    assert [i.get() for i in v2] == [2, 3]
+
+    v3, v4 = m1.LocalVec2(), m2.LocalVec2()
+    v3.append(m1.NonLocalType(1))
+    v3.append(m1.NonLocalType(2))
+    v4.append(m1.NonLocalType(1))
+    v4.append(m1.NonLocalType(2))
+
+    assert [i.get() for i in v3] == [1, 2]
+    assert [i.get() for i in v4] == [1, 2]
+
+    d1, d2 = m1.LocalMap(), m2.LocalMap()
+    d1["a"] = v1[0]
+    d1["b"] = v1[1]
+    d2["c"] = v2[0]
+    d2["d"] = v2[1]
+    assert {i: d1[i].get() for i in d1} == {'a': 0, 'b': 1}
+    assert {i: d2[i].get() for i in d2} == {'c': 2, 'd': 3}
+
+
+def test_stl_bind_global():
+    import pybind11_local_bindings as m2
+
+    with pytest.raises(RuntimeError) as excinfo:
+        m2.register_nonlocal_stl1()
+    assert str(excinfo.value) == 'generic_type: type "NonLocalVec" is already registered!'
+
+    with pytest.raises(RuntimeError) as excinfo:
+        m2.register_nonlocal_stl2()
+    assert str(excinfo.value) == 'generic_type: type "NonLocalMap" is already registered!'