xcoll 0.5.12__py3-none-any.whl → 0.6.1__py3-none-any.whl

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_numpy_vectorize.py

@@ -1,267 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-from pybind11_tests import numpy_vectorize as m
-
-np = pytest.importorskip("numpy")
-
-
-def test_vectorize(capture):
-    assert np.isclose(m.vectorized_func3(np.array(3 + 7j)), [6 + 14j])
-
-    for f in [m.vectorized_func, m.vectorized_func2]:
-        with capture:
-            assert np.isclose(f(1, 2, 3), 6)
-        assert capture == "my_func(x:int=1, y:float=2, z:float=3)"
-        with capture:
-            assert np.isclose(f(np.array(1), np.array(2), 3), 6)
-        assert capture == "my_func(x:int=1, y:float=2, z:float=3)"
-        with capture:
-            assert np.allclose(f(np.array([1, 3]), np.array([2, 4]), 3), [6, 36])
-        assert (
-            capture
-            == """
-            my_func(x:int=1, y:float=2, z:float=3)
-            my_func(x:int=3, y:float=4, z:float=3)
-        """
-        )
-        with capture:
-            a = np.array([[1, 2], [3, 4]], order="F")
-            b = np.array([[10, 20], [30, 40]], order="F")
-            c = 3
-            result = f(a, b, c)
-            assert np.allclose(result, a * b * c)
-            assert result.flags.f_contiguous
-        # All inputs are F order and full or singletons, so we the result is in col-major order:
-        assert (
-            capture
-            == """
-            my_func(x:int=1, y:float=10, z:float=3)
-            my_func(x:int=3, y:float=30, z:float=3)
-            my_func(x:int=2, y:float=20, z:float=3)
-            my_func(x:int=4, y:float=40, z:float=3)
-        """
-        )
-        with capture:
-            a, b, c = (
-                np.array([[1, 3, 5], [7, 9, 11]]),
-                np.array([[2, 4, 6], [8, 10, 12]]),
-                3,
-            )
-            assert np.allclose(f(a, b, c), a * b * c)
-        assert (
-            capture
-            == """
-            my_func(x:int=1, y:float=2, z:float=3)
-            my_func(x:int=3, y:float=4, z:float=3)
-            my_func(x:int=5, y:float=6, z:float=3)
-            my_func(x:int=7, y:float=8, z:float=3)
-            my_func(x:int=9, y:float=10, z:float=3)
-            my_func(x:int=11, y:float=12, z:float=3)
-        """
-        )
-        with capture:
-            a, b, c = np.array([[1, 2, 3], [4, 5, 6]]), np.array([2, 3, 4]), 2
-            assert np.allclose(f(a, b, c), a * b * c)
-        assert (
-            capture
-            == """
-            my_func(x:int=1, y:float=2, z:float=2)
-            my_func(x:int=2, y:float=3, z:float=2)
-            my_func(x:int=3, y:float=4, z:float=2)
-            my_func(x:int=4, y:float=2, z:float=2)
-            my_func(x:int=5, y:float=3, z:float=2)
-            my_func(x:int=6, y:float=4, z:float=2)
-        """
-        )
-        with capture:
-            a, b, c = np.array([[1, 2, 3], [4, 5, 6]]), np.array([[2], [3]]), 2
-            assert np.allclose(f(a, b, c), a * b * c)
-        assert (
-            capture
-            == """
-            my_func(x:int=1, y:float=2, z:float=2)
-            my_func(x:int=2, y:float=2, z:float=2)
-            my_func(x:int=3, y:float=2, z:float=2)
-            my_func(x:int=4, y:float=3, z:float=2)
-            my_func(x:int=5, y:float=3, z:float=2)
-            my_func(x:int=6, y:float=3, z:float=2)
-        """
-        )
-        with capture:
-            a, b, c = (
-                np.array([[1, 2, 3], [4, 5, 6]], order="F"),
-                np.array([[2], [3]]),
-                2,
-            )
-            assert np.allclose(f(a, b, c), a * b * c)
-        assert (
-            capture
-            == """
-            my_func(x:int=1, y:float=2, z:float=2)
-            my_func(x:int=2, y:float=2, z:float=2)
-            my_func(x:int=3, y:float=2, z:float=2)
-            my_func(x:int=4, y:float=3, z:float=2)
-            my_func(x:int=5, y:float=3, z:float=2)
-            my_func(x:int=6, y:float=3, z:float=2)
-        """
-        )
-        with capture:
-            a, b, c = np.array([[1, 2, 3], [4, 5, 6]])[::, ::2], np.array([[2], [3]]), 2
-            assert np.allclose(f(a, b, c), a * b * c)
-        assert (
-            capture
-            == """
-            my_func(x:int=1, y:float=2, z:float=2)
-            my_func(x:int=3, y:float=2, z:float=2)
-            my_func(x:int=4, y:float=3, z:float=2)
-            my_func(x:int=6, y:float=3, z:float=2)
-        """
-        )
-        with capture:
-            a, b, c = (
-                np.array([[1, 2, 3], [4, 5, 6]], order="F")[::, ::2],
-                np.array([[2], [3]]),
-                2,
-            )
-            assert np.allclose(f(a, b, c), a * b * c)
-        assert (
-            capture
-            == """
-            my_func(x:int=1, y:float=2, z:float=2)
-            my_func(x:int=3, y:float=2, z:float=2)
-            my_func(x:int=4, y:float=3, z:float=2)
-            my_func(x:int=6, y:float=3, z:float=2)
-        """
-        )
-
-
-def test_type_selection():
-    assert m.selective_func(np.array([1], dtype=np.int32)) == "Int branch taken."
-    assert m.selective_func(np.array([1.0], dtype=np.float32)) == "Float branch taken."
-    assert (
-        m.selective_func(np.array([1.0j], dtype=np.complex64))
-        == "Complex float branch taken."
-    )
-
-
-def test_docs(doc):
-    assert (
-        doc(m.vectorized_func)
-        == """
-        vectorized_func(arg0: numpy.ndarray[numpy.int32], arg1: numpy.ndarray[numpy.float32], arg2: numpy.ndarray[numpy.float64]) -> object
-    """  # noqa: E501 line too long
-    )
-
-
-def test_trivial_broadcasting():
-    trivial, vectorized_is_trivial = m.trivial, m.vectorized_is_trivial
-
-    assert vectorized_is_trivial(1, 2, 3) == trivial.c_trivial
-    assert vectorized_is_trivial(np.array(1), np.array(2), 3) == trivial.c_trivial
-    assert (
-        vectorized_is_trivial(np.array([1, 3]), np.array([2, 4]), 3)
-        == trivial.c_trivial
-    )
-    assert trivial.c_trivial == vectorized_is_trivial(
-        np.array([[1, 3, 5], [7, 9, 11]]), np.array([[2, 4, 6], [8, 10, 12]]), 3
-    )
-    assert (
-        vectorized_is_trivial(np.array([[1, 2, 3], [4, 5, 6]]), np.array([2, 3, 4]), 2)
-        == trivial.non_trivial
-    )
-    assert (
-        vectorized_is_trivial(np.array([[1, 2, 3], [4, 5, 6]]), np.array([[2], [3]]), 2)
-        == trivial.non_trivial
-    )
-    z1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], dtype="int32")
-    z2 = np.array(z1, dtype="float32")
-    z3 = np.array(z1, dtype="float64")
-    assert vectorized_is_trivial(z1, z2, z3) == trivial.c_trivial
-    assert vectorized_is_trivial(1, z2, z3) == trivial.c_trivial
-    assert vectorized_is_trivial(z1, 1, z3) == trivial.c_trivial
-    assert vectorized_is_trivial(z1, z2, 1) == trivial.c_trivial
-    assert vectorized_is_trivial(z1[::2, ::2], 1, 1) == trivial.non_trivial
-    assert vectorized_is_trivial(1, 1, z1[::2, ::2]) == trivial.c_trivial
-    assert vectorized_is_trivial(1, 1, z3[::2, ::2]) == trivial.non_trivial
-    assert vectorized_is_trivial(z1, 1, z3[1::4, 1::4]) == trivial.c_trivial
-
-    y1 = np.array(z1, order="F")
-    y2 = np.array(y1)
-    y3 = np.array(y1)
-    assert vectorized_is_trivial(y1, y2, y3) == trivial.f_trivial
-    assert vectorized_is_trivial(y1, 1, 1) == trivial.f_trivial
-    assert vectorized_is_trivial(1, y2, 1) == trivial.f_trivial
-    assert vectorized_is_trivial(1, 1, y3) == trivial.f_trivial
-    assert vectorized_is_trivial(y1, z2, 1) == trivial.non_trivial
-    assert vectorized_is_trivial(z1[1::4, 1::4], y2, 1) == trivial.f_trivial
-    assert vectorized_is_trivial(y1[1::4, 1::4], z2, 1) == trivial.c_trivial
-
-    assert m.vectorized_func(z1, z2, z3).flags.c_contiguous
-    assert m.vectorized_func(y1, y2, y3).flags.f_contiguous
-    assert m.vectorized_func(z1, 1, 1).flags.c_contiguous
-    assert m.vectorized_func(1, y2, 1).flags.f_contiguous
-    assert m.vectorized_func(z1[1::4, 1::4], y2, 1).flags.f_contiguous
-    assert m.vectorized_func(y1[1::4, 1::4], z2, 1).flags.c_contiguous
-
-
-def test_passthrough_arguments(doc):
-    assert doc(m.vec_passthrough) == (
-        "vec_passthrough("
-        + ", ".join(
-            [
-                "arg0: float",
-                "arg1: numpy.ndarray[numpy.float64]",
-                "arg2: numpy.ndarray[numpy.float64]",
-                "arg3: numpy.ndarray[numpy.int32]",
-                "arg4: int",
-                "arg5: m.numpy_vectorize.NonPODClass",
-                "arg6: numpy.ndarray[numpy.float64]",
-            ]
-        )
-        + ") -> object"
-    )
-
-    b = np.array([[10, 20, 30]], dtype="float64")
-    c = np.array([100, 200])  # NOT a vectorized argument
-    d = np.array([[1000], [2000], [3000]], dtype="int")
-    g = np.array([[1000000, 2000000, 3000000]], dtype="int")  # requires casting
-    assert np.all(
-        m.vec_passthrough(1, b, c, d, 10000, m.NonPODClass(100000), g)
-        == np.array(
-            [
-                [1111111, 2111121, 3111131],
-                [1112111, 2112121, 3112131],
-                [1113111, 2113121, 3113131],
-            ]
-        )
-    )
-
-
-def test_method_vectorization():
-    o = m.VectorizeTestClass(3)
-    x = np.array([1, 2], dtype="int")
-    y = np.array([[10], [20]], dtype="float32")
-    assert np.all(o.method(x, y) == [[14, 15], [24, 25]])
-
-
-def test_array_collapse():
-    assert not isinstance(m.vectorized_func(1, 2, 3), np.ndarray)
-    assert not isinstance(m.vectorized_func(np.array(1), 2, 3), np.ndarray)
-    z = m.vectorized_func([1], 2, 3)
-    assert isinstance(z, np.ndarray)
-    assert z.shape == (1,)
-    z = m.vectorized_func(1, [[[2]]], 3)
-    assert isinstance(z, np.ndarray)
-    assert z.shape == (1, 1, 1)
-
-
-def test_vectorized_noreturn():
-    x = m.NonPODClass(0)
-    assert x.value == 0
-    m.add_to(x, [1, 2, 3, 4])
-    assert x.value == 10
-    m.add_to(x, 1)
-    assert x.value == 11
-    m.add_to(x, [[1, 1], [2, 3]])
-    assert x.value == 18

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_opaque_types.cpp

@@ -1,73 +0,0 @@
-/*
-    tests/test_opaque_types.cpp -- opaque types, passing void pointers
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include <pybind11/stl.h>
-#include <vector>
-
-// IMPORTANT: Disable internal pybind11 translation mechanisms for STL data structures
-//
-// This also deliberately doesn't use the below StringList type alias to test
-// that MAKE_OPAQUE can handle a type containing a `,`.  (The `std::allocator`
-// bit is just the default `std::vector` allocator).
-PYBIND11_MAKE_OPAQUE(std::vector<std::string, std::allocator<std::string>>);
-
-using StringList = std::vector<std::string, std::allocator<std::string>>;
-
-TEST_SUBMODULE(opaque_types, m) {
-    // test_string_list
-    py::class_<StringList>(m, "StringList")
-        .def(py::init<>())
-        .def("pop_back", &StringList::pop_back)
-        /* There are multiple versions of push_back(), etc. Select the right ones. */
-        .def("push_back", (void (StringList::*)(const std::string &)) &StringList::push_back)
-        .def("back", (std::string &(StringList::*)()) &StringList::back)
-        .def("__len__", [](const StringList &v) { return v.size(); })
-        .def("__iter__", [](StringList &v) {
-           return py::make_iterator(v.begin(), v.end());
-        }, py::keep_alive<0, 1>());
-
-    class ClassWithSTLVecProperty {
-    public:
-        StringList stringList;
-    };
-    py::class_<ClassWithSTLVecProperty>(m, "ClassWithSTLVecProperty")
-        .def(py::init<>())
-        .def_readwrite("stringList", &ClassWithSTLVecProperty::stringList);
-
-    m.def("print_opaque_list", [](const StringList &l) {
-        std::string ret = "Opaque list: [";
-        bool first = true;
-        for (const auto &entry : l) {
-            if (!first)
-                ret += ", ";
-            ret += entry;
-            first = false;
-        }
-        return ret + "]";
-    });
-
-    // test_pointers
-    m.def("return_void_ptr", []() { return (void *) 0x1234; });
-    m.def("get_void_ptr_value", [](void *ptr) { return reinterpret_cast<std::intptr_t>(ptr); });
-    m.def("return_null_str", []() { return (char *) nullptr; });
-    m.def("get_null_str_value", [](char *ptr) { return reinterpret_cast<std::intptr_t>(ptr); });
-
-    m.def("return_unique_ptr", []() -> std::unique_ptr<StringList> {
-        auto *result = new StringList();
-        result->push_back("some value");
-        return std::unique_ptr<StringList>(result);
-    });
-
-    // test unions
-    py::class_<IntFloat>(m, "IntFloat")
-        .def(py::init<>())
-        .def_readwrite("i", &IntFloat::i)
-        .def_readwrite("f", &IntFloat::f);
-}

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_opaque_types.py

@@ -1,59 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-from pybind11_tests import ConstructorStats, UserType
-from pybind11_tests import opaque_types as m
-
-
-def test_string_list():
-    lst = m.StringList()
-    lst.push_back("Element 1")
-    lst.push_back("Element 2")
-    assert m.print_opaque_list(lst) == "Opaque list: [Element 1, Element 2]"
-    assert lst.back() == "Element 2"
-
-    for i, k in enumerate(lst, start=1):
-        assert k == "Element {}".format(i)
-    lst.pop_back()
-    assert m.print_opaque_list(lst) == "Opaque list: [Element 1]"
-
-    cvp = m.ClassWithSTLVecProperty()
-    assert m.print_opaque_list(cvp.stringList) == "Opaque list: []"
-
-    cvp.stringList = lst
-    cvp.stringList.push_back("Element 3")
-    assert m.print_opaque_list(cvp.stringList) == "Opaque list: [Element 1, Element 3]"
-
-
-def test_pointers(msg):
-    living_before = ConstructorStats.get(UserType).alive()
-    assert m.get_void_ptr_value(m.return_void_ptr()) == 0x1234
-    assert m.get_void_ptr_value(UserType())  # Should also work for other C++ types
-    assert ConstructorStats.get(UserType).alive() == living_before
-
-    with pytest.raises(TypeError) as excinfo:
-        m.get_void_ptr_value([1, 2, 3])  # This should not work
-    assert (
-        msg(excinfo.value)
-        == """
-        get_void_ptr_value(): incompatible function arguments. The following argument types are supported:
-            1. (arg0: capsule) -> int
-
-        Invoked with: [1, 2, 3]
-    """  # noqa: E501 line too long
-    )
-
-    assert m.return_null_str() is None
-    assert m.get_null_str_value(m.return_null_str()) is not None
-
-    ptr = m.return_unique_ptr()
-    assert "StringList" in repr(ptr)
-    assert m.print_opaque_list(ptr) == "Opaque list: [some value]"
-
-
-def test_unions():
-    int_float_union = m.IntFloat()
-    int_float_union.i = 42
-    assert int_float_union.i == 42
-    int_float_union.f = 3.0
-    assert int_float_union.f == 3.0

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_operator_overloading.cpp

@@ -1,235 +0,0 @@
-/*
-    tests/test_operator_overloading.cpp -- operator overloading
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-#include <pybind11/operators.h>
-#include <functional>
-
-class Vector2 {
-public:
-    Vector2(float x, float y) : x(x), y(y) { print_created(this, toString()); }
-    Vector2(const Vector2 &v) : x(v.x), y(v.y) { print_copy_created(this); }
-    Vector2(Vector2 &&v) noexcept : x(v.x), y(v.y) {
-        print_move_created(this);
-        v.x = v.y = 0;
-    }
-    Vector2 &operator=(const Vector2 &v) { x = v.x; y = v.y; print_copy_assigned(this); return *this; }
-    Vector2 &operator=(Vector2 &&v) noexcept {
-        x   = v.x;
-        y   = v.y;
-        v.x = v.y = 0;
-        print_move_assigned(this);
-        return *this;
-    }
-    ~Vector2() { print_destroyed(this); }
-
-    std::string toString() const { return "[" + std::to_string(x) + ", " + std::to_string(y) + "]"; }
-
-    Vector2 operator-() const { return Vector2(-x, -y); }
-    Vector2 operator+(const Vector2 &v) const { return Vector2(x + v.x, y + v.y); }
-    Vector2 operator-(const Vector2 &v) const { return Vector2(x - v.x, y - v.y); }
-    Vector2 operator-(float value) const { return Vector2(x - value, y - value); }
-    Vector2 operator+(float value) const { return Vector2(x + value, y + value); }
-    Vector2 operator*(float value) const { return Vector2(x * value, y * value); }
-    Vector2 operator/(float value) const { return Vector2(x / value, y / value); }
-    Vector2 operator*(const Vector2 &v) const { return Vector2(x * v.x, y * v.y); }
-    Vector2 operator/(const Vector2 &v) const { return Vector2(x / v.x, y / v.y); }
-    Vector2& operator+=(const Vector2 &v) { x += v.x; y += v.y; return *this; }
-    Vector2& operator-=(const Vector2 &v) { x -= v.x; y -= v.y; return *this; }
-    Vector2& operator*=(float v) { x *= v; y *= v; return *this; }
-    Vector2& operator/=(float v) { x /= v; y /= v; return *this; }
-    Vector2& operator*=(const Vector2 &v) { x *= v.x; y *= v.y; return *this; }
-    Vector2& operator/=(const Vector2 &v) { x /= v.x; y /= v.y; return *this; }
-
-    friend Vector2 operator+(float f, const Vector2 &v) { return Vector2(f + v.x, f + v.y); }
-    friend Vector2 operator-(float f, const Vector2 &v) { return Vector2(f - v.x, f - v.y); }
-    friend Vector2 operator*(float f, const Vector2 &v) { return Vector2(f * v.x, f * v.y); }
-    friend Vector2 operator/(float f, const Vector2 &v) { return Vector2(f / v.x, f / v.y); }
-
-    bool operator==(const Vector2 &v) const {
-        return x == v.x && y == v.y;
-    }
-    bool operator!=(const Vector2 &v) const {
-        return x != v.x || y != v.y;
-    }
-private:
-    float x, y;
-};
-
-class C1 { };
-class C2 { };
-
-int operator+(const C1 &, const C1 &) { return 11; }
-int operator+(const C2 &, const C2 &) { return 22; }
-int operator+(const C2 &, const C1 &) { return 21; }
-int operator+(const C1 &, const C2 &) { return 12; }
-
-// Note: Specializing explicit within `namespace std { ... }` is done due to a
-// bug in GCC<7. If you are supporting compilers later than this, consider
-// specializing `using template<> struct std::hash<...>` in the global
-// namespace instead, per this recommendation:
-// https://en.cppreference.com/w/cpp/language/extending_std#Adding_template_specializations
-namespace std {
-    template<>
-    struct hash<Vector2> {
-        // Not a good hash function, but easy to test
-        size_t operator()(const Vector2 &) { return 4; }
-    };
-} // namespace std
-
-// Not a good abs function, but easy to test.
-std::string abs(const Vector2&) {
-    return "abs(Vector2)";
-}
-
-// MSVC & Intel warns about unknown pragmas, and warnings are errors.
-#if !defined(_MSC_VER) && !defined(__INTEL_COMPILER)
-  #pragma GCC diagnostic push
-  // clang 7.0.0 and Apple LLVM 10.0.1 introduce `-Wself-assign-overloaded` to
-  // `-Wall`, which is used here for overloading (e.g. `py::self += py::self `).
-  // Here, we suppress the warning using `#pragma diagnostic`.
-  // Taken from: https://github.com/RobotLocomotion/drake/commit/aaf84b46
-  // TODO(eric): This could be resolved using a function / functor (e.g. `py::self()`).
-  #if defined(__APPLE__) && defined(__clang__)
-    #if (__clang_major__ >= 10)
-      #pragma GCC diagnostic ignored "-Wself-assign-overloaded"
-    #endif
-  #elif defined(__clang__)
-    #if (__clang_major__ >= 7)
-      #pragma GCC diagnostic ignored "-Wself-assign-overloaded"
-    #endif
-  #endif
-#endif
-
-TEST_SUBMODULE(operators, m) {
-
-    // test_operator_overloading
-    py::class_<Vector2>(m, "Vector2")
-        .def(py::init<float, float>())
-        .def(py::self + py::self)
-        .def(py::self + float())
-        .def(py::self - py::self)
-        .def(py::self - float())
-        .def(py::self * float())
-        .def(py::self / float())
-        .def(py::self * py::self)
-        .def(py::self / py::self)
-        .def(py::self += py::self)
-        .def(py::self -= py::self)
-        .def(py::self *= float())
-        .def(py::self /= float())
-        .def(py::self *= py::self)
-        .def(py::self /= py::self)
-        .def(float() + py::self)
-        .def(float() - py::self)
-        .def(float() * py::self)
-        .def(float() / py::self)
-        .def(-py::self)
-        .def("__str__", &Vector2::toString)
-        .def("__repr__", &Vector2::toString)
-        .def(py::self == py::self)
-        .def(py::self != py::self)
-        .def(py::hash(py::self))
-        // N.B. See warning about usage of `py::detail::abs(py::self)` in
-        // `operators.h`.
-        .def("__abs__", [](const Vector2& v) { return abs(v); })
-        ;
-
-    m.attr("Vector") = m.attr("Vector2");
-
-    // test_operators_notimplemented
-    // #393: need to return NotSupported to ensure correct arithmetic operator behavior
-    py::class_<C1>(m, "C1")
-        .def(py::init<>())
-        .def(py::self + py::self);
-
-    py::class_<C2>(m, "C2")
-        .def(py::init<>())
-        .def(py::self + py::self)
-        .def("__add__", [](const C2& c2, const C1& c1) { return c2 + c1; })
-        .def("__radd__", [](const C2& c2, const C1& c1) { return c1 + c2; });
-
-    // test_nested
-    // #328: first member in a class can't be used in operators
-    struct NestABase { int value = -2; };
-    py::class_<NestABase>(m, "NestABase")
-        .def(py::init<>())
-        .def_readwrite("value", &NestABase::value);
-
-    struct NestA : NestABase {
-        int value = 3;
-        NestA& operator+=(int i) { value += i; return *this; }
-    };
-    py::class_<NestA>(m, "NestA")
-        .def(py::init<>())
-        .def(py::self += int())
-        .def("as_base", [](NestA &a) -> NestABase& {
-            return (NestABase&) a;
-        }, py::return_value_policy::reference_internal);
-    m.def("get_NestA", [](const NestA &a) { return a.value; });
-
-    struct NestB {
-        NestA a;
-        int value = 4;
-        NestB& operator-=(int i) { value -= i; return *this; }
-    };
-    py::class_<NestB>(m, "NestB")
-        .def(py::init<>())
-        .def(py::self -= int())
-        .def_readwrite("a", &NestB::a);
-    m.def("get_NestB", [](const NestB &b) { return b.value; });
-
-    struct NestC {
-        NestB b;
-        int value = 5;
-        NestC& operator*=(int i) { value *= i; return *this; }
-    };
-    py::class_<NestC>(m, "NestC")
-        .def(py::init<>())
-        .def(py::self *= int())
-        .def_readwrite("b", &NestC::b);
-    m.def("get_NestC", [](const NestC &c) { return c.value; });
-
-
-    // test_overriding_eq_reset_hash
-    // #2191 Overriding __eq__ should set __hash__ to None
-    struct Comparable {
-        int value;
-        bool operator==(const Comparable& rhs) const {return value == rhs.value;}
-    };
-
-    struct Hashable : Comparable {
-        explicit Hashable(int value): Comparable{value}{};
-        size_t hash() const { return static_cast<size_t>(value); }
-    };
-
-    struct Hashable2 : Hashable {
-        using Hashable::Hashable;
-    };
-
-    py::class_<Comparable>(m, "Comparable")
-        .def(py::init<int>())
-        .def(py::self == py::self);
-
-    py::class_<Hashable>(m, "Hashable")
-        .def(py::init<int>())
-        .def(py::self == py::self)
-        .def("__hash__", &Hashable::hash);
-
-    // define __hash__ before __eq__
-    py::class_<Hashable2>(m, "Hashable2")
-        .def("__hash__", &Hashable::hash)
-        .def(py::init<int>())
-        .def(py::self == py::self);
-}
-
-#if !defined(_MSC_VER) && !defined(__INTEL_COMPILER)
-  #pragma GCC diagnostic pop
-#endif