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

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

@@ -1,248 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-import env  # noqa: F401
-from pybind11_tests import ConstructorStats
-from pybind11_tests import call_policies as m
-
-
-@pytest.mark.xfail("env.PYPY", reason="sometimes comes out 1 off on PyPy", strict=False)
-def test_keep_alive_argument(capture):
-    n_inst = ConstructorStats.detail_reg_inst()
-    with capture:
-        p = m.Parent()
-    assert capture == "Allocating parent."
-    with capture:
-        p.addChild(m.Child())
-        assert ConstructorStats.detail_reg_inst() == n_inst + 1
-    assert (
-        capture
-        == """
-        Allocating child.
-        Releasing child.
-    """
-    )
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert capture == "Releasing parent."
-
-    with capture:
-        p = m.Parent()
-    assert capture == "Allocating parent."
-    with capture:
-        p.addChildKeepAlive(m.Child())
-        assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    assert capture == "Allocating child."
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-    """
-    )
-
-    p = m.Parent()
-    c = m.Child()
-    assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    m.free_function(p, c)
-    del c
-    assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    del p
-    assert ConstructorStats.detail_reg_inst() == n_inst
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.invalid_arg_index()
-    assert str(excinfo.value) == "Could not activate keep_alive!"
-
-
-def test_keep_alive_return_value(capture):
-    n_inst = ConstructorStats.detail_reg_inst()
-    with capture:
-        p = m.Parent()
-    assert capture == "Allocating parent."
-    with capture:
-        p.returnChild()
-        assert ConstructorStats.detail_reg_inst() == n_inst + 1
-    assert (
-        capture
-        == """
-        Allocating child.
-        Releasing child.
-    """
-    )
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert capture == "Releasing parent."
-
-    with capture:
-        p = m.Parent()
-    assert capture == "Allocating parent."
-    with capture:
-        p.returnChildKeepAlive()
-        assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    assert capture == "Allocating child."
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-    """
-    )
-
-    p = m.Parent()
-    assert ConstructorStats.detail_reg_inst() == n_inst + 1
-    with capture:
-        m.Parent.staticFunction(p)
-        assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    assert capture == "Allocating child."
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-    """
-    )
-
-
-# https://foss.heptapod.net/pypy/pypy/-/issues/2447
-@pytest.mark.xfail("env.PYPY", reason="_PyObject_GetDictPtr is unimplemented")
-def test_alive_gc(capture):
-    n_inst = ConstructorStats.detail_reg_inst()
-    p = m.ParentGC()
-    p.addChildKeepAlive(m.Child())
-    assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    lst = [p]
-    lst.append(lst)  # creates a circular reference
-    with capture:
-        del p, lst
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-    """
-    )
-
-
-def test_alive_gc_derived(capture):
-    class Derived(m.Parent):
-        pass
-
-    n_inst = ConstructorStats.detail_reg_inst()
-    p = Derived()
-    p.addChildKeepAlive(m.Child())
-    assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    lst = [p]
-    lst.append(lst)  # creates a circular reference
-    with capture:
-        del p, lst
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-    """
-    )
-
-
-def test_alive_gc_multi_derived(capture):
-    class Derived(m.Parent, m.Child):
-        def __init__(self):
-            m.Parent.__init__(self)
-            m.Child.__init__(self)
-
-    n_inst = ConstructorStats.detail_reg_inst()
-    p = Derived()
-    p.addChildKeepAlive(m.Child())
-    # +3 rather than +2 because Derived corresponds to two registered instances
-    assert ConstructorStats.detail_reg_inst() == n_inst + 3
-    lst = [p]
-    lst.append(lst)  # creates a circular reference
-    with capture:
-        del p, lst
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-        Releasing child.
-    """
-    )
-
-
-def test_return_none(capture):
-    n_inst = ConstructorStats.detail_reg_inst()
-    with capture:
-        p = m.Parent()
-    assert capture == "Allocating parent."
-    with capture:
-        p.returnNullChildKeepAliveChild()
-        assert ConstructorStats.detail_reg_inst() == n_inst + 1
-    assert capture == ""
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert capture == "Releasing parent."
-
-    with capture:
-        p = m.Parent()
-    assert capture == "Allocating parent."
-    with capture:
-        p.returnNullChildKeepAliveParent()
-        assert ConstructorStats.detail_reg_inst() == n_inst + 1
-    assert capture == ""
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert capture == "Releasing parent."
-
-
-def test_keep_alive_constructor(capture):
-    n_inst = ConstructorStats.detail_reg_inst()
-
-    with capture:
-        p = m.Parent(m.Child())
-        assert ConstructorStats.detail_reg_inst() == n_inst + 2
-    assert (
-        capture
-        == """
-        Allocating child.
-        Allocating parent.
-    """
-    )
-    with capture:
-        del p
-        assert ConstructorStats.detail_reg_inst() == n_inst
-    assert (
-        capture
-        == """
-        Releasing parent.
-        Releasing child.
-    """
-    )
-
-
-def test_call_guard():
-    assert m.unguarded_call() == "unguarded"
-    assert m.guarded_call() == "guarded"
-
-    assert m.multiple_guards_correct_order() == "guarded & guarded"
-    assert m.multiple_guards_wrong_order() == "unguarded & guarded"
-
-    if hasattr(m, "with_gil"):
-        assert m.with_gil() == "GIL held"
-        assert m.without_gil() == "GIL released"

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

@@ -1,227 +0,0 @@
-/*
-    tests/test_callbacks.cpp -- callbacks
-
-    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/functional.h>
-#include <thread>
-
-
-int dummy_function(int i) { return i + 1; }
-
-TEST_SUBMODULE(callbacks, m) {
-    // test_callbacks, test_function_signatures
-    m.def("test_callback1", [](const py::object &func) { return func(); });
-    m.def("test_callback2", [](const py::object &func) { return func("Hello", 'x', true, 5); });
-    m.def("test_callback3", [](const std::function<int(int)> &func) {
-        return "func(43) = " + std::to_string(func(43)); });
-    m.def("test_callback4", []() -> std::function<int(int)> { return [](int i) { return i+1; }; });
-    m.def("test_callback5", []() {
-        return py::cpp_function([](int i) { return i+1; }, py::arg("number"));
-    });
-
-    // test_keyword_args_and_generalized_unpacking
-    m.def("test_tuple_unpacking", [](const py::function &f) {
-        auto t1 = py::make_tuple(2, 3);
-        auto t2 = py::make_tuple(5, 6);
-        return f("positional", 1, *t1, 4, *t2);
-    });
-
-    m.def("test_dict_unpacking", [](const py::function &f) {
-        auto d1 = py::dict("key"_a="value", "a"_a=1);
-        auto d2 = py::dict();
-        auto d3 = py::dict("b"_a=2);
-        return f("positional", 1, **d1, **d2, **d3);
-    });
-
-    m.def("test_keyword_args", [](const py::function &f) { return f("x"_a = 10, "y"_a = 20); });
-
-    m.def("test_unpacking_and_keywords1", [](const py::function &f) {
-        auto args = py::make_tuple(2);
-        auto kwargs = py::dict("d"_a=4);
-        return f(1, *args, "c"_a=3, **kwargs);
-    });
-
-    m.def("test_unpacking_and_keywords2", [](const py::function &f) {
-        auto kwargs1 = py::dict("a"_a=1);
-        auto kwargs2 = py::dict("c"_a=3, "d"_a=4);
-        return f("positional", *py::make_tuple(1), 2, *py::make_tuple(3, 4), 5,
-                 "key"_a="value", **kwargs1, "b"_a=2, **kwargs2, "e"_a=5);
-    });
-
-    m.def("test_unpacking_error1", [](const py::function &f) {
-        auto kwargs = py::dict("x"_a=3);
-        return f("x"_a=1, "y"_a=2, **kwargs); // duplicate ** after keyword
-    });
-
-    m.def("test_unpacking_error2", [](const py::function &f) {
-        auto kwargs = py::dict("x"_a=3);
-        return f(**kwargs, "x"_a=1); // duplicate keyword after **
-    });
-
-    m.def("test_arg_conversion_error1",
-          [](const py::function &f) { f(234, UnregisteredType(), "kw"_a = 567); });
-
-    m.def("test_arg_conversion_error2", [](const py::function &f) {
-        f(234, "expected_name"_a=UnregisteredType(), "kw"_a=567);
-    });
-
-    // test_lambda_closure_cleanup
-    struct Payload {
-        Payload() { print_default_created(this); }
-        ~Payload() { print_destroyed(this); }
-        Payload(const Payload &) { print_copy_created(this); }
-        Payload(Payload &&) noexcept { print_move_created(this); }
-    };
-    // Export the payload constructor statistics for testing purposes:
-    m.def("payload_cstats", &ConstructorStats::get<Payload>);
-    m.def("test_lambda_closure_cleanup", []() -> std::function<void()> {
-        Payload p;
-
-        // In this situation, `Func` in the implementation of
-        // `cpp_function::initialize` is NOT trivially destructible.
-        return [p]() {
-            /* p should be cleaned up when the returned function is garbage collected */
-            (void) p;
-        };
-    });
-
-    class CppCallable {
-    public:
-        CppCallable() { track_default_created(this); }
-        ~CppCallable() { track_destroyed(this); }
-        CppCallable(const CppCallable &) { track_copy_created(this); }
-        CppCallable(CppCallable &&) noexcept { track_move_created(this); }
-        void operator()() {}
-    };
-
-    m.def("test_cpp_callable_cleanup", []() {
-        // Related issue: https://github.com/pybind/pybind11/issues/3228
-        // Related PR: https://github.com/pybind/pybind11/pull/3229
-        py::list alive_counts;
-        ConstructorStats &stat = ConstructorStats::get<CppCallable>();
-        alive_counts.append(stat.alive());
-        {
-            CppCallable cpp_callable;
-            alive_counts.append(stat.alive());
-            {
-                // In this situation, `Func` in the implementation of
-                // `cpp_function::initialize` IS trivially destructible,
-                // only `capture` is not.
-                py::cpp_function py_func(cpp_callable);
-                py::detail::silence_unused_warnings(py_func);
-                alive_counts.append(stat.alive());
-            }
-            alive_counts.append(stat.alive());
-            {
-                py::cpp_function py_func(std::move(cpp_callable));
-                py::detail::silence_unused_warnings(py_func);
-                alive_counts.append(stat.alive());
-            }
-            alive_counts.append(stat.alive());
-        }
-        alive_counts.append(stat.alive());
-        return alive_counts;
-    });
-
-    // test_cpp_function_roundtrip
-    /* Test if passing a function pointer from C++ -> Python -> C++ yields the original pointer */
-    m.def("dummy_function", &dummy_function);
-    m.def("dummy_function_overloaded", [](int i, int j) { return i + j; });
-    m.def("dummy_function_overloaded", &dummy_function);
-    m.def("dummy_function2", [](int i, int j) { return i + j; });
-    m.def("roundtrip", [](std::function<int(int)> f, bool expect_none = false) {
-        if (expect_none && f)
-            throw std::runtime_error("Expected None to be converted to empty std::function");
-        return f;
-    }, py::arg("f"), py::arg("expect_none")=false);
-    m.def("test_dummy_function", [](const std::function<int(int)> &f) -> std::string {
-        using fn_type = int (*)(int);
-        auto result = f.target<fn_type>();
-        if (!result) {
-            auto r = f(1);
-            return "can't convert to function pointer: eval(1) = " + std::to_string(r);
-        }
-        if (*result == dummy_function) {
-            auto r = (*result)(1);
-            return "matches dummy_function: eval(1) = " + std::to_string(r);
-        }
-        return "argument does NOT match dummy_function. This should never happen!";
-
-    });
-
-    class AbstractBase {
-    public:
-        // [workaround(intel)] = default does not work here
-        // Defaulting this destructor results in linking errors with the Intel compiler
-        // (in Debug builds only, tested with icpc (ICC) 2021.1 Beta 20200827)
-        virtual ~AbstractBase() {} // NOLINT(modernize-use-equals-default)
-        virtual unsigned int func() = 0;
-    };
-    m.def("func_accepting_func_accepting_base",
-          [](const std::function<double(AbstractBase &)> &) {});
-
-    struct MovableObject {
-        bool valid = true;
-
-        MovableObject() = default;
-        MovableObject(const MovableObject &) = default;
-        MovableObject &operator=(const MovableObject &) = default;
-        MovableObject(MovableObject &&o) noexcept : valid(o.valid) { o.valid = false; }
-        MovableObject &operator=(MovableObject &&o) noexcept {
-            valid = o.valid;
-            o.valid = false;
-            return *this;
-        }
-    };
-    py::class_<MovableObject>(m, "MovableObject");
-
-    // test_movable_object
-    m.def("callback_with_movable", [](const std::function<void(MovableObject &)> &f) {
-        auto x = MovableObject();
-        f(x); // lvalue reference shouldn't move out object
-        return x.valid; // must still return `true`
-    });
-
-    // test_bound_method_callback
-    struct CppBoundMethodTest {};
-    py::class_<CppBoundMethodTest>(m, "CppBoundMethodTest")
-        .def(py::init<>())
-        .def("triple", [](CppBoundMethodTest &, int val) { return 3 * val; });
-
-    // This checks that builtin functions can be passed as callbacks
-    // rather than throwing RuntimeError due to trying to extract as capsule
-    m.def("test_sum_builtin", [](const std::function<double(py::iterable)> &sum_builtin, const py::iterable &i) {
-      return sum_builtin(i);
-    });
-
-    // test async Python callbacks
-    using callback_f = std::function<void(int)>;
-    m.def("test_async_callback", [](const callback_f &f, const py::list &work) {
-        // make detached thread that calls `f` with piece of work after a little delay
-        auto start_f = [f](int j) {
-            auto invoke_f = [f, j] {
-                std::this_thread::sleep_for(std::chrono::milliseconds(50));
-                f(j);
-            };
-            auto t = std::thread(std::move(invoke_f));
-            t.detach();
-        };
-
-        // spawn worker threads
-        for (auto i : work)
-            start_f(py::cast<int>(i));
-    });
-
-    m.def("callback_num_times", [](const py::function &f, std::size_t num) {
-        for (std::size_t i = 0; i < num; i++) {
-            f();
-        }
-    });
-}

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

@@ -1,202 +0,0 @@
-# -*- coding: utf-8 -*-
-import time
-from threading import Thread
-
-import pytest
-
-import env  # noqa: F401
-from pybind11_tests import callbacks as m
-
-
-def test_callbacks():
-    from functools import partial
-
-    def func1():
-        return "func1"
-
-    def func2(a, b, c, d):
-        return "func2", a, b, c, d
-
-    def func3(a):
-        return "func3({})".format(a)
-
-    assert m.test_callback1(func1) == "func1"
-    assert m.test_callback2(func2) == ("func2", "Hello", "x", True, 5)
-    assert m.test_callback1(partial(func2, 1, 2, 3, 4)) == ("func2", 1, 2, 3, 4)
-    assert m.test_callback1(partial(func3, "partial")) == "func3(partial)"
-    assert m.test_callback3(lambda i: i + 1) == "func(43) = 44"
-
-    f = m.test_callback4()
-    assert f(43) == 44
-    f = m.test_callback5()
-    assert f(number=43) == 44
-
-
-def test_bound_method_callback():
-    # Bound Python method:
-    class MyClass:
-        def double(self, val):
-            return 2 * val
-
-    z = MyClass()
-    assert m.test_callback3(z.double) == "func(43) = 86"
-
-    z = m.CppBoundMethodTest()
-    assert m.test_callback3(z.triple) == "func(43) = 129"
-
-
-def test_keyword_args_and_generalized_unpacking():
-    def f(*args, **kwargs):
-        return args, kwargs
-
-    assert m.test_tuple_unpacking(f) == (("positional", 1, 2, 3, 4, 5, 6), {})
-    assert m.test_dict_unpacking(f) == (
-        ("positional", 1),
-        {"key": "value", "a": 1, "b": 2},
-    )
-    assert m.test_keyword_args(f) == ((), {"x": 10, "y": 20})
-    assert m.test_unpacking_and_keywords1(f) == ((1, 2), {"c": 3, "d": 4})
-    assert m.test_unpacking_and_keywords2(f) == (
-        ("positional", 1, 2, 3, 4, 5),
-        {"key": "value", "a": 1, "b": 2, "c": 3, "d": 4, "e": 5},
-    )
-
-    with pytest.raises(TypeError) as excinfo:
-        m.test_unpacking_error1(f)
-    assert "Got multiple values for keyword argument" in str(excinfo.value)
-
-    with pytest.raises(TypeError) as excinfo:
-        m.test_unpacking_error2(f)
-    assert "Got multiple values for keyword argument" in str(excinfo.value)
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.test_arg_conversion_error1(f)
-    assert "Unable to convert call argument" in str(excinfo.value)
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.test_arg_conversion_error2(f)
-    assert "Unable to convert call argument" in str(excinfo.value)
-
-
-def test_lambda_closure_cleanup():
-    m.test_lambda_closure_cleanup()
-    cstats = m.payload_cstats()
-    assert cstats.alive() == 0
-    assert cstats.copy_constructions == 1
-    assert cstats.move_constructions >= 1
-
-
-def test_cpp_callable_cleanup():
-    alive_counts = m.test_cpp_callable_cleanup()
-    assert alive_counts == [0, 1, 2, 1, 2, 1, 0]
-
-
-def test_cpp_function_roundtrip():
-    """Test if passing a function pointer from C++ -> Python -> C++ yields the original pointer"""
-
-    assert (
-        m.test_dummy_function(m.dummy_function) == "matches dummy_function: eval(1) = 2"
-    )
-    assert (
-        m.test_dummy_function(m.roundtrip(m.dummy_function))
-        == "matches dummy_function: eval(1) = 2"
-    )
-    assert (
-        m.test_dummy_function(m.dummy_function_overloaded)
-        == "matches dummy_function: eval(1) = 2"
-    )
-    assert m.roundtrip(None, expect_none=True) is None
-    assert (
-        m.test_dummy_function(lambda x: x + 2)
-        == "can't convert to function pointer: eval(1) = 3"
-    )
-
-    with pytest.raises(TypeError) as excinfo:
-        m.test_dummy_function(m.dummy_function2)
-    assert "incompatible function arguments" in str(excinfo.value)
-
-    with pytest.raises(TypeError) as excinfo:
-        m.test_dummy_function(lambda x, y: x + y)
-    assert any(
-        s in str(excinfo.value)
-        for s in ("missing 1 required positional argument", "takes exactly 2 arguments")
-    )
-
-
-def test_function_signatures(doc):
-    assert doc(m.test_callback3) == "test_callback3(arg0: Callable[[int], int]) -> str"
-    assert doc(m.test_callback4) == "test_callback4() -> Callable[[int], int]"
-
-
-def test_movable_object():
-    assert m.callback_with_movable(lambda _: None) is True
-
-
-@pytest.mark.skipif(
-    "env.PYPY",
-    reason="PyPy segfaults on here. See discussion on #1413.",
-)
-def test_python_builtins():
-    """Test if python builtins like sum() can be used as callbacks"""
-    assert m.test_sum_builtin(sum, [1, 2, 3]) == 6
-    assert m.test_sum_builtin(sum, []) == 0
-
-
-def test_async_callbacks():
-    # serves as state for async callback
-    class Item:
-        def __init__(self, value):
-            self.value = value
-
-    res = []
-
-    # generate stateful lambda that will store result in `res`
-    def gen_f():
-        s = Item(3)
-        return lambda j: res.append(s.value + j)
-
-    # do some work async
-    work = [1, 2, 3, 4]
-    m.test_async_callback(gen_f(), work)
-    # wait until work is done
-    from time import sleep
-
-    sleep(0.5)
-    assert sum(res) == sum(x + 3 for x in work)
-
-
-def test_async_async_callbacks():
-    t = Thread(target=test_async_callbacks)
-    t.start()
-    t.join()
-
-
-def test_callback_num_times():
-    # Super-simple micro-benchmarking related to PR #2919.
-    # Example runtimes (Intel Xeon 2.2GHz, fully optimized):
-    #   num_millions  1, repeats  2:  0.1 secs
-    #   num_millions 20, repeats 10: 11.5 secs
-    one_million = 1000000
-    num_millions = 1  # Try 20 for actual micro-benchmarking.
-    repeats = 2  # Try 10.
-    rates = []
-    for rep in range(repeats):
-        t0 = time.time()
-        m.callback_num_times(lambda: None, num_millions * one_million)
-        td = time.time() - t0
-        rate = num_millions / td if td else 0
-        rates.append(rate)
-        if not rep:
-            print()
-        print(
-            "callback_num_times: {:d} million / {:.3f} seconds = {:.3f} million / second".format(
-                num_millions, td, rate
-            )
-        )
-    if len(rates) > 1:
-        print("Min    Mean   Max")
-        print(
-            "{:6.3f} {:6.3f} {:6.3f}".format(
-                min(rates), sum(rates) / len(rates), max(rates)
-            )
-        )