mirror of
https://github.com/RYDE-WORK/pybind11.git
synced 2026-01-22 14:57:07 +08:00
7437c69500
This commit adds a `py::module_local` attribute that lets you confine a
registered type to the module (more technically, the shared object) in
which it is defined, by registering it with:
py::class_<C>(m, "C", py::module_local())
This will allow the same C++ class `C` to be registered in different
modules with independent sets of class definitions. On the Python side,
two such types will be completely distinct; on the C++ side, the C++
type resolves to a different Python type in each module.
This applies `py::module_local` automatically to `stl_bind.h` bindings
when the container value type looks like something global: i.e. when it
is a converting type (for example, when binding a `std::vector<int>`),
or when it is a registered type itself bound with `py::module_local`.
This should help resolve potential future conflicts (e.g. if two
completely unrelated modules both try to bind a `std::vector<int>`.
Users can override the automatic selection by adding a
`py::module_local()` or `py::module_local(false)`.
Note that this does mildly break backwards compatibility: bound stl
containers of basic types like `std::vector<int>` cannot be bound in one
module and returned in a different module. (This can be re-enabled with
`py::module_local(false)` as described above, but with the potential for
eventual load conflicts).
110 lines
3.4 KiB
Python
110 lines
3.4 KiB
Python
import pytest
|
|
|
|
from pybind11_tests import local_bindings as m
|
|
|
|
|
|
def test_local_bindings():
|
|
"""Tests that duplicate py::local class bindings work across modules"""
|
|
|
|
# Make sure we can load the second module with the conflicting (but local) definition:
|
|
import pybind11_cross_module_tests as cm
|
|
|
|
i1 = m.LocalType(5)
|
|
|
|
assert i1.get() == 4
|
|
assert i1.get3() == 8
|
|
|
|
i2 = cm.LocalType(10)
|
|
assert i2.get() == 11
|
|
assert i2.get2() == 12
|
|
|
|
assert not hasattr(i1, 'get2')
|
|
assert not hasattr(i2, 'get3')
|
|
|
|
assert m.local_value(i1) == 5
|
|
assert cm.local_value(i2) == 10
|
|
|
|
with pytest.raises(TypeError) as excinfo:
|
|
m.local_value(i2)
|
|
assert "incompatible function arguments" in str(excinfo.value)
|
|
|
|
with pytest.raises(TypeError) as excinfo:
|
|
cm.local_value(i1)
|
|
assert "incompatible function arguments" in str(excinfo.value)
|
|
|
|
|
|
def test_nonlocal_failure():
|
|
"""Tests that attempting to register a non-local type in multiple modules fails"""
|
|
import pybind11_cross_module_tests as cm
|
|
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
cm.register_nonlocal()
|
|
assert str(excinfo.value) == 'generic_type: type "NonLocalType" is already registered!'
|
|
|
|
|
|
def test_duplicate_local():
|
|
"""Tests expected failure when registering a class twice with py::local in the same module"""
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
m.register_local_external()
|
|
import pybind11_tests
|
|
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_cross_module_tests as cm
|
|
|
|
v1, v2 = m.LocalVec(), cm.LocalVec()
|
|
v1.append(m.LocalType(1))
|
|
v1.append(m.LocalType(2))
|
|
v2.append(cm.LocalType(1))
|
|
v2.append(cm.LocalType(2))
|
|
|
|
with pytest.raises(TypeError):
|
|
v1.append(cm.LocalType(3))
|
|
with pytest.raises(TypeError):
|
|
v2.append(m.LocalType(3))
|
|
|
|
assert [i.get() for i in v1] == [0, 1]
|
|
assert [i.get() for i in v2] == [2, 3]
|
|
|
|
v3, v4 = m.NonLocalVec(), cm.NonLocalVec2()
|
|
v3.append(m.NonLocalType(1))
|
|
v3.append(m.NonLocalType(2))
|
|
v4.append(m.NonLocal2(3))
|
|
v4.append(m.NonLocal2(4))
|
|
|
|
assert [i.get() for i in v3] == [1, 2]
|
|
assert [i.get() for i in v4] == [13, 14]
|
|
|
|
d1, d2 = m.LocalMap(), cm.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_cross_module_tests as cm
|
|
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
cm.register_nonlocal_map()
|
|
assert str(excinfo.value) == 'generic_type: type "NonLocalMap" is already registered!'
|
|
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
cm.register_nonlocal_vec()
|
|
assert str(excinfo.value) == 'generic_type: type "NonLocalVec" is already registered!'
|
|
|
|
with pytest.raises(RuntimeError) as excinfo:
|
|
cm.register_nonlocal_map2()
|
|
assert str(excinfo.value) == 'generic_type: type "NonLocalMap2" is already registered!'
|
|
|
|
|
|
def test_internal_locals_differ():
|
|
"""Makes sure the internal local type map differs across the two modules"""
|
|
import pybind11_cross_module_tests as cm
|
|
assert m.local_cpp_types_addr() != cm.local_cpp_types_addr()
|