xcoll 0.5.11__py3-none-any.whl → 0.6.0__py3-none-any.whl

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

@@ -1,520 +0,0 @@
-# -*- coding: utf-8 -*-
-import re
-
-import pytest
-
-import env  # noqa: F401
-from pybind11_tests import ConstructorStats
-from pybind11_tests import factory_constructors as m
-from pybind11_tests.factory_constructors import tag
-
-
-def test_init_factory_basic():
-    """Tests py::init_factory() wrapper around various ways of returning the object"""
-
-    cstats = [
-        ConstructorStats.get(c)
-        for c in [m.TestFactory1, m.TestFactory2, m.TestFactory3]
-    ]
-    cstats[0].alive()  # force gc
-    n_inst = ConstructorStats.detail_reg_inst()
-
-    x1 = m.TestFactory1(tag.unique_ptr, 3)
-    assert x1.value == "3"
-    y1 = m.TestFactory1(tag.pointer)
-    assert y1.value == "(empty)"
-    z1 = m.TestFactory1("hi!")
-    assert z1.value == "hi!"
-
-    assert ConstructorStats.detail_reg_inst() == n_inst + 3
-
-    x2 = m.TestFactory2(tag.move)
-    assert x2.value == "(empty2)"
-    y2 = m.TestFactory2(tag.pointer, 7)
-    assert y2.value == "7"
-    z2 = m.TestFactory2(tag.unique_ptr, "hi again")
-    assert z2.value == "hi again"
-
-    assert ConstructorStats.detail_reg_inst() == n_inst + 6
-
-    x3 = m.TestFactory3(tag.shared_ptr)
-    assert x3.value == "(empty3)"
-    y3 = m.TestFactory3(tag.pointer, 42)
-    assert y3.value == "42"
-    z3 = m.TestFactory3("bye")
-    assert z3.value == "bye"
-
-    for null_ptr_kind in [tag.null_ptr, tag.null_unique_ptr, tag.null_shared_ptr]:
-        with pytest.raises(TypeError) as excinfo:
-            m.TestFactory3(null_ptr_kind)
-        assert (
-            str(excinfo.value) == "pybind11::init(): factory function returned nullptr"
-        )
-
-    assert [i.alive() for i in cstats] == [3, 3, 3]
-    assert ConstructorStats.detail_reg_inst() == n_inst + 9
-
-    del x1, y2, y3, z3
-    assert [i.alive() for i in cstats] == [2, 2, 1]
-    assert ConstructorStats.detail_reg_inst() == n_inst + 5
-    del x2, x3, y1, z1, z2
-    assert [i.alive() for i in cstats] == [0, 0, 0]
-    assert ConstructorStats.detail_reg_inst() == n_inst
-
-    assert [i.values() for i in cstats] == [
-        ["3", "hi!"],
-        ["7", "hi again"],
-        ["42", "bye"],
-    ]
-    assert [i.default_constructions for i in cstats] == [1, 1, 1]
-
-
-def test_init_factory_signature(msg):
-    with pytest.raises(TypeError) as excinfo:
-        m.TestFactory1("invalid", "constructor", "arguments")
-    assert (
-        msg(excinfo.value)
-        == """
-        __init__(): incompatible constructor arguments. The following argument types are supported:
-            1. m.factory_constructors.TestFactory1(arg0: m.factory_constructors.tag.unique_ptr_tag, arg1: int)
-            2. m.factory_constructors.TestFactory1(arg0: str)
-            3. m.factory_constructors.TestFactory1(arg0: m.factory_constructors.tag.pointer_tag)
-            4. m.factory_constructors.TestFactory1(arg0: handle, arg1: int, arg2: handle)
-
-        Invoked with: 'invalid', 'constructor', 'arguments'
-    """  # noqa: E501 line too long
-    )
-
-    assert (
-        msg(m.TestFactory1.__init__.__doc__)
-        == """
-        __init__(*args, **kwargs)
-        Overloaded function.
-
-        1. __init__(self: m.factory_constructors.TestFactory1, arg0: m.factory_constructors.tag.unique_ptr_tag, arg1: int) -> None
-
-        2. __init__(self: m.factory_constructors.TestFactory1, arg0: str) -> None
-
-        3. __init__(self: m.factory_constructors.TestFactory1, arg0: m.factory_constructors.tag.pointer_tag) -> None
-
-        4. __init__(self: m.factory_constructors.TestFactory1, arg0: handle, arg1: int, arg2: handle) -> None
-    """  # noqa: E501 line too long
-    )
-
-
-def test_init_factory_casting():
-    """Tests py::init_factory() wrapper with various upcasting and downcasting returns"""
-
-    cstats = [
-        ConstructorStats.get(c)
-        for c in [m.TestFactory3, m.TestFactory4, m.TestFactory5]
-    ]
-    cstats[0].alive()  # force gc
-    n_inst = ConstructorStats.detail_reg_inst()
-
-    # Construction from derived references:
-    a = m.TestFactory3(tag.pointer, tag.TF4, 4)
-    assert a.value == "4"
-    b = m.TestFactory3(tag.shared_ptr, tag.TF4, 5)
-    assert b.value == "5"
-    c = m.TestFactory3(tag.pointer, tag.TF5, 6)
-    assert c.value == "6"
-    d = m.TestFactory3(tag.shared_ptr, tag.TF5, 7)
-    assert d.value == "7"
-
-    assert ConstructorStats.detail_reg_inst() == n_inst + 4
-
-    # Shared a lambda with TF3:
-    e = m.TestFactory4(tag.pointer, tag.TF4, 8)
-    assert e.value == "8"
-
-    assert ConstructorStats.detail_reg_inst() == n_inst + 5
-    assert [i.alive() for i in cstats] == [5, 3, 2]
-
-    del a
-    assert [i.alive() for i in cstats] == [4, 2, 2]
-    assert ConstructorStats.detail_reg_inst() == n_inst + 4
-
-    del b, c, e
-    assert [i.alive() for i in cstats] == [1, 0, 1]
-    assert ConstructorStats.detail_reg_inst() == n_inst + 1
-
-    del d
-    assert [i.alive() for i in cstats] == [0, 0, 0]
-    assert ConstructorStats.detail_reg_inst() == n_inst
-
-    assert [i.values() for i in cstats] == [
-        ["4", "5", "6", "7", "8"],
-        ["4", "5", "8"],
-        ["6", "7"],
-    ]
-
-
-def test_init_factory_alias():
-    """Tests py::init_factory() wrapper with value conversions and alias types"""
-
-    cstats = [m.TestFactory6.get_cstats(), m.TestFactory6.get_alias_cstats()]
-    cstats[0].alive()  # force gc
-    n_inst = ConstructorStats.detail_reg_inst()
-
-    a = m.TestFactory6(tag.base, 1)
-    assert a.get() == 1
-    assert not a.has_alias()
-    b = m.TestFactory6(tag.alias, "hi there")
-    assert b.get() == 8
-    assert b.has_alias()
-    c = m.TestFactory6(tag.alias, 3)
-    assert c.get() == 3
-    assert c.has_alias()
-    d = m.TestFactory6(tag.alias, tag.pointer, 4)
-    assert d.get() == 4
-    assert d.has_alias()
-    e = m.TestFactory6(tag.base, tag.pointer, 5)
-    assert e.get() == 5
-    assert not e.has_alias()
-    f = m.TestFactory6(tag.base, tag.alias, tag.pointer, 6)
-    assert f.get() == 6
-    assert f.has_alias()
-
-    assert ConstructorStats.detail_reg_inst() == n_inst + 6
-    assert [i.alive() for i in cstats] == [6, 4]
-
-    del a, b, e
-    assert [i.alive() for i in cstats] == [3, 3]
-    assert ConstructorStats.detail_reg_inst() == n_inst + 3
-    del f, c, d
-    assert [i.alive() for i in cstats] == [0, 0]
-    assert ConstructorStats.detail_reg_inst() == n_inst
-
-    class MyTest(m.TestFactory6):
-        def __init__(self, *args):
-            m.TestFactory6.__init__(self, *args)
-
-        def get(self):
-            return -5 + m.TestFactory6.get(self)
-
-    # Return Class by value, moved into new alias:
-    z = MyTest(tag.base, 123)
-    assert z.get() == 118
-    assert z.has_alias()
-
-    # Return alias by value, moved into new alias:
-    y = MyTest(tag.alias, "why hello!")
-    assert y.get() == 5
-    assert y.has_alias()
-
-    # Return Class by pointer, moved into new alias then original destroyed:
-    x = MyTest(tag.base, tag.pointer, 47)
-    assert x.get() == 42
-    assert x.has_alias()
-
-    assert ConstructorStats.detail_reg_inst() == n_inst + 3
-    assert [i.alive() for i in cstats] == [3, 3]
-    del x, y, z
-    assert [i.alive() for i in cstats] == [0, 0]
-    assert ConstructorStats.detail_reg_inst() == n_inst
-
-    assert [i.values() for i in cstats] == [
-        ["1", "8", "3", "4", "5", "6", "123", "10", "47"],
-        ["hi there", "3", "4", "6", "move", "123", "why hello!", "move", "47"],
-    ]
-
-
-def test_init_factory_dual():
-    """Tests init factory functions with dual main/alias factory functions"""
-    from pybind11_tests.factory_constructors import TestFactory7
-
-    cstats = [TestFactory7.get_cstats(), TestFactory7.get_alias_cstats()]
-    cstats[0].alive()  # force gc
-    n_inst = ConstructorStats.detail_reg_inst()
-
-    class PythFactory7(TestFactory7):
-        def get(self):
-            return 100 + TestFactory7.get(self)
-
-    a1 = TestFactory7(1)
-    a2 = PythFactory7(2)
-    assert a1.get() == 1
-    assert a2.get() == 102
-    assert not a1.has_alias()
-    assert a2.has_alias()
-
-    b1 = TestFactory7(tag.pointer, 3)
-    b2 = PythFactory7(tag.pointer, 4)
-    assert b1.get() == 3
-    assert b2.get() == 104
-    assert not b1.has_alias()
-    assert b2.has_alias()
-
-    c1 = TestFactory7(tag.mixed, 5)
-    c2 = PythFactory7(tag.mixed, 6)
-    assert c1.get() == 5
-    assert c2.get() == 106
-    assert not c1.has_alias()
-    assert c2.has_alias()
-
-    d1 = TestFactory7(tag.base, tag.pointer, 7)
-    d2 = PythFactory7(tag.base, tag.pointer, 8)
-    assert d1.get() == 7
-    assert d2.get() == 108
-    assert not d1.has_alias()
-    assert d2.has_alias()
-
-    # Both return an alias; the second multiplies the value by 10:
-    e1 = TestFactory7(tag.alias, tag.pointer, 9)
-    e2 = PythFactory7(tag.alias, tag.pointer, 10)
-    assert e1.get() == 9
-    assert e2.get() == 200
-    assert e1.has_alias()
-    assert e2.has_alias()
-
-    f1 = TestFactory7(tag.shared_ptr, tag.base, 11)
-    f2 = PythFactory7(tag.shared_ptr, tag.base, 12)
-    assert f1.get() == 11
-    assert f2.get() == 112
-    assert not f1.has_alias()
-    assert f2.has_alias()
-
-    g1 = TestFactory7(tag.shared_ptr, tag.invalid_base, 13)
-    assert g1.get() == 13
-    assert not g1.has_alias()
-    with pytest.raises(TypeError) as excinfo:
-        PythFactory7(tag.shared_ptr, tag.invalid_base, 14)
-    assert (
-        str(excinfo.value)
-        == "pybind11::init(): construction failed: returned holder-wrapped instance is not an "
-        "alias instance"
-    )
-
-    assert [i.alive() for i in cstats] == [13, 7]
-    assert ConstructorStats.detail_reg_inst() == n_inst + 13
-
-    del a1, a2, b1, d1, e1, e2
-    assert [i.alive() for i in cstats] == [7, 4]
-    assert ConstructorStats.detail_reg_inst() == n_inst + 7
-    del b2, c1, c2, d2, f1, f2, g1
-    assert [i.alive() for i in cstats] == [0, 0]
-    assert ConstructorStats.detail_reg_inst() == n_inst
-
-    assert [i.values() for i in cstats] == [
-        ["1", "2", "3", "4", "5", "6", "7", "8", "9", "100", "11", "12", "13", "14"],
-        ["2", "4", "6", "8", "9", "100", "12"],
-    ]
-
-
-def test_no_placement_new(capture):
-    """Prior to 2.2, `py::init<...>` relied on the type supporting placement
-    new; this tests a class without placement new support."""
-    with capture:
-        a = m.NoPlacementNew(123)
-
-    found = re.search(r"^operator new called, returning (\d+)\n$", str(capture))
-    assert found
-    assert a.i == 123
-    with capture:
-        del a
-        pytest.gc_collect()
-    assert capture == "operator delete called on " + found.group(1)
-
-    with capture:
-        b = m.NoPlacementNew()
-
-    found = re.search(r"^operator new called, returning (\d+)\n$", str(capture))
-    assert found
-    assert b.i == 100
-    with capture:
-        del b
-        pytest.gc_collect()
-    assert capture == "operator delete called on " + found.group(1)
-
-
-def test_multiple_inheritance():
-    class MITest(m.TestFactory1, m.TestFactory2):
-        def __init__(self):
-            m.TestFactory1.__init__(self, tag.unique_ptr, 33)
-            m.TestFactory2.__init__(self, tag.move)
-
-    a = MITest()
-    assert m.TestFactory1.value.fget(a) == "33"
-    assert m.TestFactory2.value.fget(a) == "(empty2)"
-
-
-def create_and_destroy(*args):
-    a = m.NoisyAlloc(*args)
-    print("---")
-    del a
-    pytest.gc_collect()
-
-
-def strip_comments(s):
-    return re.sub(r"\s+#.*", "", s)
-
-
-def test_reallocation_a(capture, msg):
-    """When the constructor is overloaded, previous overloads can require a preallocated value.
-    This test makes sure that such preallocated values only happen when they might be necessary,
-    and that they are deallocated properly."""
-
-    pytest.gc_collect()
-
-    with capture:
-        create_and_destroy(1)
-    assert (
-        msg(capture)
-        == """
-        noisy new
-        noisy placement new
-        NoisyAlloc(int 1)
-        ---
-        ~NoisyAlloc()
-        noisy delete
-    """
-    )
-
-
-def test_reallocation_b(capture, msg):
-    with capture:
-        create_and_destroy(1.5)
-    assert msg(capture) == strip_comments(
-        """
-        noisy new               # allocation required to attempt first overload
-        noisy delete            # have to dealloc before considering factory init overload
-        noisy new               # pointer factory calling "new", part 1: allocation
-        NoisyAlloc(double 1.5)  # ... part two, invoking constructor
-        ---
-        ~NoisyAlloc()  # Destructor
-        noisy delete   # operator delete
-    """
-    )
-
-
-def test_reallocation_c(capture, msg):
-    with capture:
-        create_and_destroy(2, 3)
-    assert msg(capture) == strip_comments(
-        """
-        noisy new          # pointer factory calling "new", allocation
-        NoisyAlloc(int 2)  # constructor
-        ---
-        ~NoisyAlloc()  # Destructor
-        noisy delete   # operator delete
-    """
-    )
-
-
-def test_reallocation_d(capture, msg):
-    with capture:
-        create_and_destroy(2.5, 3)
-    assert msg(capture) == strip_comments(
-        """
-        NoisyAlloc(double 2.5)  # construction (local func variable: operator_new not called)
-        noisy new               # return-by-value "new" part 1: allocation
-        ~NoisyAlloc()           # moved-away local func variable destruction
-        ---
-        ~NoisyAlloc()  # Destructor
-        noisy delete   # operator delete
-    """
-    )
-
-
-def test_reallocation_e(capture, msg):
-    with capture:
-        create_and_destroy(3.5, 4.5)
-    assert msg(capture) == strip_comments(
-        """
-        noisy new               # preallocation needed before invoking placement-new overload
-        noisy placement new     # Placement new
-        NoisyAlloc(double 3.5)  # construction
-        ---
-        ~NoisyAlloc()  # Destructor
-        noisy delete   # operator delete
-    """
-    )
-
-
-def test_reallocation_f(capture, msg):
-    with capture:
-        create_and_destroy(4, 0.5)
-    assert msg(capture) == strip_comments(
-        """
-        noisy new          # preallocation needed before invoking placement-new overload
-        noisy delete       # deallocation of preallocated storage
-        noisy new          # Factory pointer allocation
-        NoisyAlloc(int 4)  # factory pointer construction
-        ---
-        ~NoisyAlloc()  # Destructor
-        noisy delete   # operator delete
-    """
-    )
-
-
-def test_reallocation_g(capture, msg):
-    with capture:
-        create_and_destroy(5, "hi")
-    assert msg(capture) == strip_comments(
-        """
-        noisy new            # preallocation needed before invoking first placement new
-        noisy delete         # delete before considering new-style constructor
-        noisy new            # preallocation for second placement new
-        noisy placement new  # Placement new in the second placement new overload
-        NoisyAlloc(int 5)    # construction
-        ---
-        ~NoisyAlloc()  # Destructor
-        noisy delete   # operator delete
-    """
-    )
-
-
-@pytest.mark.skipif("env.PY2")
-def test_invalid_self():
-    """Tests invocation of the pybind-registered base class with an invalid `self` argument.  You
-    can only actually do this on Python 3: Python 2 raises an exception itself if you try."""
-
-    class NotPybindDerived(object):
-        pass
-
-    # Attempts to initialize with an invalid type passed as `self`:
-    class BrokenTF1(m.TestFactory1):
-        def __init__(self, bad):
-            if bad == 1:
-                a = m.TestFactory2(tag.pointer, 1)
-                m.TestFactory1.__init__(a, tag.pointer)
-            elif bad == 2:
-                a = NotPybindDerived()
-                m.TestFactory1.__init__(a, tag.pointer)
-
-    # Same as above, but for a class with an alias:
-    class BrokenTF6(m.TestFactory6):
-        def __init__(self, bad):
-            if bad == 0:
-                m.TestFactory6.__init__()
-            elif bad == 1:
-                a = m.TestFactory2(tag.pointer, 1)
-                m.TestFactory6.__init__(a, tag.base, 1)
-            elif bad == 2:
-                a = m.TestFactory2(tag.pointer, 1)
-                m.TestFactory6.__init__(a, tag.alias, 1)
-            elif bad == 3:
-                m.TestFactory6.__init__(
-                    NotPybindDerived.__new__(NotPybindDerived), tag.base, 1
-                )
-            elif bad == 4:
-                m.TestFactory6.__init__(
-                    NotPybindDerived.__new__(NotPybindDerived), tag.alias, 1
-                )
-
-    for arg in (1, 2):
-        with pytest.raises(TypeError) as excinfo:
-            BrokenTF1(arg)
-        assert (
-            str(excinfo.value)
-            == "__init__(self, ...) called with invalid or missing `self` argument"
-        )
-
-    for arg in (0, 1, 2, 3, 4):
-        with pytest.raises(TypeError) as excinfo:
-            BrokenTF6(arg)
-        assert (
-            str(excinfo.value)
-            == "__init__(self, ...) called with invalid or missing `self` argument"
-        )

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

@@ -1,49 +0,0 @@
-/*
-    tests/test_gil_scoped.cpp -- acquire and release gil
-
-    Copyright (c) 2017 Borja Zarco (Google LLC) <bzarco@google.com>
-
-    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/functional.h>
-
-
-class VirtClass  {
-public:
-    virtual ~VirtClass() = default;
-    VirtClass() = default;
-    VirtClass(const VirtClass&) = delete;
-    virtual void virtual_func() {}
-    virtual void pure_virtual_func() = 0;
-};
-
-class PyVirtClass : public VirtClass {
-    void virtual_func() override {
-        PYBIND11_OVERRIDE(void, VirtClass, virtual_func,);
-    }
-    void pure_virtual_func() override {
-        PYBIND11_OVERRIDE_PURE(void, VirtClass, pure_virtual_func,);
-    }
-};
-
-TEST_SUBMODULE(gil_scoped, m) {
-  py::class_<VirtClass, PyVirtClass>(m, "VirtClass")
-      .def(py::init<>())
-      .def("virtual_func", &VirtClass::virtual_func)
-      .def("pure_virtual_func", &VirtClass::pure_virtual_func);
-
-  m.def("test_callback_py_obj", [](py::object &func) { func(); });
-  m.def("test_callback_std_func", [](const std::function<void()> &func) { func(); });
-  m.def("test_callback_virtual_func", [](VirtClass &virt) { virt.virtual_func(); });
-  m.def("test_callback_pure_virtual_func", [](VirtClass &virt) { virt.pure_virtual_func(); });
-  m.def("test_cross_module_gil", []() {
-      auto cm = py::module_::import("cross_module_gil_utils");
-      auto gil_acquire
-          = reinterpret_cast<void (*)()>(PyLong_AsVoidPtr(cm.attr("gil_acquire_funcaddr").ptr()));
-      py::gil_scoped_release gil_release;
-      gil_acquire();
-  });
-}

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

@@ -1,94 +0,0 @@
-# -*- coding: utf-8 -*-
-import multiprocessing
-import threading
-
-from pybind11_tests import gil_scoped as m
-
-
-def _run_in_process(target, *args, **kwargs):
-    """Runs target in process and returns its exitcode after 10s (None if still alive)."""
-    process = multiprocessing.Process(target=target, args=args, kwargs=kwargs)
-    process.daemon = True
-    try:
-        process.start()
-        # Do not need to wait much, 10s should be more than enough.
-        process.join(timeout=10)
-        return process.exitcode
-    finally:
-        if process.is_alive():
-            process.terminate()
-
-
-def _python_to_cpp_to_python():
-    """Calls different C++ functions that come back to Python."""
-
-    class ExtendedVirtClass(m.VirtClass):
-        def virtual_func(self):
-            pass
-
-        def pure_virtual_func(self):
-            pass
-
-    extended = ExtendedVirtClass()
-    m.test_callback_py_obj(lambda: None)
-    m.test_callback_std_func(lambda: None)
-    m.test_callback_virtual_func(extended)
-    m.test_callback_pure_virtual_func(extended)
-
-
-def _python_to_cpp_to_python_from_threads(num_threads, parallel=False):
-    """Calls different C++ functions that come back to Python, from Python threads."""
-    threads = []
-    for _ in range(num_threads):
-        thread = threading.Thread(target=_python_to_cpp_to_python)
-        thread.daemon = True
-        thread.start()
-        if parallel:
-            threads.append(thread)
-        else:
-            thread.join()
-    for thread in threads:
-        thread.join()
-
-
-# TODO: FIXME, sometimes returns -11 (segfault) instead of 0 on macOS Python 3.9
-def test_python_to_cpp_to_python_from_thread():
-    """Makes sure there is no GIL deadlock when running in a thread.
-
-    It runs in a separate process to be able to stop and assert if it deadlocks.
-    """
-    assert _run_in_process(_python_to_cpp_to_python_from_threads, 1) == 0
-
-
-# TODO: FIXME on macOS Python 3.9
-def test_python_to_cpp_to_python_from_thread_multiple_parallel():
-    """Makes sure there is no GIL deadlock when running in a thread multiple times in parallel.
-
-    It runs in a separate process to be able to stop and assert if it deadlocks.
-    """
-    assert _run_in_process(_python_to_cpp_to_python_from_threads, 8, parallel=True) == 0
-
-
-# TODO: FIXME on macOS Python 3.9
-def test_python_to_cpp_to_python_from_thread_multiple_sequential():
-    """Makes sure there is no GIL deadlock when running in a thread multiple times sequentially.
-
-    It runs in a separate process to be able to stop and assert if it deadlocks.
-    """
-    assert (
-        _run_in_process(_python_to_cpp_to_python_from_threads, 8, parallel=False) == 0
-    )
-
-
-# TODO: FIXME on macOS Python 3.9
-def test_python_to_cpp_to_python_from_process():
-    """Makes sure there is no GIL deadlock when using processes.
-
-    This test is for completion, but it was never an issue.
-    """
-    assert _run_in_process(_python_to_cpp_to_python) == 0
-
-
-def test_cross_module_gil():
-    """Makes sure that the GIL can be acquired by another module from a GIL-released state."""
-    m.test_cross_module_gil()  # Should not raise a SIGSEGV