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

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

@@ -1,318 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-import env
-from pybind11_tests import stl_binders as m
-
-
-def test_vector_int():
-    v_int = m.VectorInt([0, 0])
-    assert len(v_int) == 2
-    assert bool(v_int) is True
-
-    # test construction from a generator
-    v_int1 = m.VectorInt(x for x in range(5))
-    assert v_int1 == m.VectorInt([0, 1, 2, 3, 4])
-
-    v_int2 = m.VectorInt([0, 0])
-    assert v_int == v_int2
-    v_int2[1] = 1
-    assert v_int != v_int2
-
-    v_int2.append(2)
-    v_int2.insert(0, 1)
-    v_int2.insert(0, 2)
-    v_int2.insert(0, 3)
-    v_int2.insert(6, 3)
-    assert str(v_int2) == "VectorInt[3, 2, 1, 0, 1, 2, 3]"
-    with pytest.raises(IndexError):
-        v_int2.insert(8, 4)
-
-    v_int.append(99)
-    v_int2[2:-2] = v_int
-    assert v_int2 == m.VectorInt([3, 2, 0, 0, 99, 2, 3])
-    del v_int2[1:3]
-    assert v_int2 == m.VectorInt([3, 0, 99, 2, 3])
-    del v_int2[0]
-    assert v_int2 == m.VectorInt([0, 99, 2, 3])
-
-    v_int2.extend(m.VectorInt([4, 5]))
-    assert v_int2 == m.VectorInt([0, 99, 2, 3, 4, 5])
-
-    v_int2.extend([6, 7])
-    assert v_int2 == m.VectorInt([0, 99, 2, 3, 4, 5, 6, 7])
-
-    # test error handling, and that the vector is unchanged
-    with pytest.raises(RuntimeError):
-        v_int2.extend([8, "a"])
-
-    assert v_int2 == m.VectorInt([0, 99, 2, 3, 4, 5, 6, 7])
-
-    # test extending from a generator
-    v_int2.extend(x for x in range(5))
-    assert v_int2 == m.VectorInt([0, 99, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4])
-
-    # test negative indexing
-    assert v_int2[-1] == 4
-
-    # insert with negative index
-    v_int2.insert(-1, 88)
-    assert v_int2 == m.VectorInt([0, 99, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 88, 4])
-
-    # delete negative index
-    del v_int2[-1]
-    assert v_int2 == m.VectorInt([0, 99, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 88])
-
-    v_int2.clear()
-    assert len(v_int2) == 0
-
-
-# Older PyPy's failed here, related to the PyPy's buffer protocol.
-def test_vector_buffer():
-    b = bytearray([1, 2, 3, 4])
-    v = m.VectorUChar(b)
-    assert v[1] == 2
-    v[2] = 5
-    mv = memoryview(v)  # We expose the buffer interface
-    if not env.PY2:
-        assert mv[2] == 5
-        mv[2] = 6
-    else:
-        assert mv[2] == "\x05"
-        mv[2] = "\x06"
-    assert v[2] == 6
-
-    if not env.PY2:
-        mv = memoryview(b)
-        v = m.VectorUChar(mv[::2])
-        assert v[1] == 3
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.create_undeclstruct()  # Undeclared struct contents, no buffer interface
-    assert "NumPy type info missing for " in str(excinfo.value)
-
-
-def test_vector_buffer_numpy():
-    np = pytest.importorskip("numpy")
-    a = np.array([1, 2, 3, 4], dtype=np.int32)
-    with pytest.raises(TypeError):
-        m.VectorInt(a)
-
-    a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.uintc)
-    v = m.VectorInt(a[0, :])
-    assert len(v) == 4
-    assert v[2] == 3
-    ma = np.asarray(v)
-    ma[2] = 5
-    assert v[2] == 5
-
-    v = m.VectorInt(a[:, 1])
-    assert len(v) == 3
-    assert v[2] == 10
-
-    v = m.get_vectorstruct()
-    assert v[0].x == 5
-    ma = np.asarray(v)
-    ma[1]["x"] = 99
-    assert v[1].x == 99
-
-    v = m.VectorStruct(
-        np.zeros(
-            3,
-            dtype=np.dtype(
-                [("w", "bool"), ("x", "I"), ("y", "float64"), ("z", "bool")], align=True
-            ),
-        )
-    )
-    assert len(v) == 3
-
-    b = np.array([1, 2, 3, 4], dtype=np.uint8)
-    v = m.VectorUChar(b[::2])
-    assert v[1] == 3
-
-
-def test_vector_bool():
-    import pybind11_cross_module_tests as cm
-
-    vv_c = cm.VectorBool()
-    for i in range(10):
-        vv_c.append(i % 2 == 0)
-    for i in range(10):
-        assert vv_c[i] == (i % 2 == 0)
-    assert str(vv_c) == "VectorBool[1, 0, 1, 0, 1, 0, 1, 0, 1, 0]"
-
-
-def test_vector_custom():
-    v_a = m.VectorEl()
-    v_a.append(m.El(1))
-    v_a.append(m.El(2))
-    assert str(v_a) == "VectorEl[El{1}, El{2}]"
-
-    vv_a = m.VectorVectorEl()
-    vv_a.append(v_a)
-    vv_b = vv_a[0]
-    assert str(vv_b) == "VectorEl[El{1}, El{2}]"
-
-
-def test_map_string_double():
-    mm = m.MapStringDouble()
-    mm["a"] = 1
-    mm["b"] = 2.5
-
-    assert list(mm) == ["a", "b"]
-    assert str(mm) == "MapStringDouble{a: 1, b: 2.5}"
-    assert "b" in mm
-    assert "c" not in mm
-    assert 123 not in mm
-
-    # Check that keys, values, items are views, not merely iterable
-    keys = mm.keys()
-    values = mm.values()
-    items = mm.items()
-    assert list(keys) == ["a", "b"]
-    assert len(keys) == 2
-    assert "a" in keys
-    assert "c" not in keys
-    assert 123 not in keys
-    assert list(items) == [("a", 1), ("b", 2.5)]
-    assert len(items) == 2
-    assert ("b", 2.5) in items
-    assert "hello" not in items
-    assert ("b", 2.5, None) not in items
-    assert list(values) == [1, 2.5]
-    assert len(values) == 2
-    assert 1 in values
-    assert 2 not in values
-    # Check that views update when the map is updated
-    mm["c"] = -1
-    assert list(keys) == ["a", "b", "c"]
-    assert list(values) == [1, 2.5, -1]
-    assert list(items) == [("a", 1), ("b", 2.5), ("c", -1)]
-
-    um = m.UnorderedMapStringDouble()
-    um["ua"] = 1.1
-    um["ub"] = 2.6
-
-    assert sorted(list(um)) == ["ua", "ub"]
-    assert list(um.keys()) == list(um)
-    assert sorted(list(um.items())) == [("ua", 1.1), ("ub", 2.6)]
-    assert list(zip(um.keys(), um.values())) == list(um.items())
-    assert "UnorderedMapStringDouble" in str(um)
-
-
-def test_map_string_double_const():
-    mc = m.MapStringDoubleConst()
-    mc["a"] = 10
-    mc["b"] = 20.5
-    assert str(mc) == "MapStringDoubleConst{a: 10, b: 20.5}"
-
-    umc = m.UnorderedMapStringDoubleConst()
-    umc["a"] = 11
-    umc["b"] = 21.5
-
-    str(umc)
-
-
-def test_noncopyable_containers():
-    # std::vector
-    vnc = m.get_vnc(5)
-    for i in range(0, 5):
-        assert vnc[i].value == i + 1
-
-    for i, j in enumerate(vnc, start=1):
-        assert j.value == i
-
-    # std::deque
-    dnc = m.get_dnc(5)
-    for i in range(0, 5):
-        assert dnc[i].value == i + 1
-
-    i = 1
-    for j in dnc:
-        assert j.value == i
-        i += 1
-
-    # std::map
-    mnc = m.get_mnc(5)
-    for i in range(1, 6):
-        assert mnc[i].value == 10 * i
-
-    vsum = 0
-    for k, v in mnc.items():
-        assert v.value == 10 * k
-        vsum += v.value
-
-    assert vsum == 150
-
-    # std::unordered_map
-    mnc = m.get_umnc(5)
-    for i in range(1, 6):
-        assert mnc[i].value == 10 * i
-
-    vsum = 0
-    for k, v in mnc.items():
-        assert v.value == 10 * k
-        vsum += v.value
-
-    assert vsum == 150
-
-    # nested std::map<std::vector>
-    nvnc = m.get_nvnc(5)
-    for i in range(1, 6):
-        for j in range(0, 5):
-            assert nvnc[i][j].value == j + 1
-
-    # Note: maps do not have .values()
-    for _, v in nvnc.items():
-        for i, j in enumerate(v, start=1):
-            assert j.value == i
-
-    # nested std::map<std::map>
-    nmnc = m.get_nmnc(5)
-    for i in range(1, 6):
-        for j in range(10, 60, 10):
-            assert nmnc[i][j].value == 10 * j
-
-    vsum = 0
-    for _, v_o in nmnc.items():
-        for k_i, v_i in v_o.items():
-            assert v_i.value == 10 * k_i
-            vsum += v_i.value
-
-    assert vsum == 7500
-
-    # nested std::unordered_map<std::unordered_map>
-    numnc = m.get_numnc(5)
-    for i in range(1, 6):
-        for j in range(10, 60, 10):
-            assert numnc[i][j].value == 10 * j
-
-    vsum = 0
-    for _, v_o in numnc.items():
-        for k_i, v_i in v_o.items():
-            assert v_i.value == 10 * k_i
-            vsum += v_i.value
-
-    assert vsum == 7500
-
-
-def test_map_delitem():
-    mm = m.MapStringDouble()
-    mm["a"] = 1
-    mm["b"] = 2.5
-
-    assert list(mm) == ["a", "b"]
-    assert list(mm.items()) == [("a", 1), ("b", 2.5)]
-    del mm["a"]
-    assert list(mm) == ["b"]
-    assert list(mm.items()) == [("b", 2.5)]
-
-    um = m.UnorderedMapStringDouble()
-    um["ua"] = 1.1
-    um["ub"] = 2.6
-
-    assert sorted(list(um)) == ["ua", "ub"]
-    assert sorted(list(um.items())) == [("ua", 1.1), ("ub", 2.6)]
-    del um["ua"]
-    assert sorted(list(um)) == ["ub"]
-    assert sorted(list(um.items())) == [("ub", 2.6)]

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

@@ -1,144 +0,0 @@
-/*
-    tests/test_tagbased_polymorphic.cpp -- test of polymorphic_type_hook
-
-    Copyright (c) 2018 Hudson River Trading LLC <opensource@hudson-trading.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/stl.h>
-
-struct Animal
-{
-    // Make this type also a "standard" polymorphic type, to confirm that
-    // specializing polymorphic_type_hook using enable_if_t still works
-    // (https://github.com/pybind/pybind11/pull/2016/).
-    virtual ~Animal() = default;
-
-    // Enum for tag-based polymorphism.
-    enum class Kind {
-        Unknown = 0,
-        Dog = 100, Labrador, Chihuahua, LastDog = 199,
-        Cat = 200, Panther, LastCat = 299
-    };
-    static const std::type_info* type_of_kind(Kind kind);
-    static std::string name_of_kind(Kind kind);
-
-    const Kind kind;
-    const std::string name;
-
-  protected:
-    Animal(const std::string& _name, Kind _kind)
-        : kind(_kind), name(_name)
-    {}
-};
-
-struct Dog : Animal
-{
-    explicit Dog(const std::string &_name, Kind _kind = Kind::Dog) : Animal(_name, _kind) {}
-    std::string bark() const { return name_of_kind(kind) + " " + name + " goes " + sound; }
-    std::string sound = "WOOF!";
-};
-
-struct Labrador : Dog
-{
-    explicit Labrador(const std::string &_name, int _excitement = 9001)
-        : Dog(_name, Kind::Labrador), excitement(_excitement) {}
-    int excitement;
-};
-
-struct Chihuahua : Dog
-{
-    explicit Chihuahua(const std::string &_name) : Dog(_name, Kind::Chihuahua) {
-        sound = "iyiyiyiyiyi";
-    }
-    std::string bark() const { return Dog::bark() + " and runs in circles"; }
-};
-
-struct Cat : Animal
-{
-    explicit Cat(const std::string &_name, Kind _kind = Kind::Cat) : Animal(_name, _kind) {}
-    std::string purr() const { return "mrowr"; }
-};
-
-struct Panther : Cat
-{
-    explicit Panther(const std::string &_name) : Cat(_name, Kind::Panther) {}
-    std::string purr() const { return "mrrrRRRRRR"; }
-};
-
-std::vector<std::unique_ptr<Animal>> create_zoo()
-{
-    std::vector<std::unique_ptr<Animal>> ret;
-    ret.emplace_back(new Labrador("Fido", 15000));
-
-    // simulate some new type of Dog that the Python bindings
-    // haven't been updated for; it should still be considered
-    // a Dog, not just an Animal.
-    ret.emplace_back(new Dog("Ginger", Dog::Kind(150)));
-
-    ret.emplace_back(new Chihuahua("Hertzl"));
-    ret.emplace_back(new Cat("Tiger", Cat::Kind::Cat));
-    ret.emplace_back(new Panther("Leo"));
-    return ret;
-}
-
-const std::type_info* Animal::type_of_kind(Kind kind)
-{
-    switch (kind) {
-        case Kind::Unknown:
-        case Kind::Dog: break;
-
-        case Kind::Labrador: return &typeid(Labrador);
-        case Kind::Chihuahua: return &typeid(Chihuahua);
-
-        case Kind::LastDog:
-        case Kind::Cat: break;
-        case Kind::Panther: return &typeid(Panther);
-        case Kind::LastCat: break;
-    }
-
-    if (kind >= Kind::Dog && kind <= Kind::LastDog) return &typeid(Dog);
-    if (kind >= Kind::Cat && kind <= Kind::LastCat) return &typeid(Cat);
-    return nullptr;
-}
-
-std::string Animal::name_of_kind(Kind kind)
-{
-    std::string raw_name = type_of_kind(kind)->name();
-    py::detail::clean_type_id(raw_name);
-    return raw_name;
-}
-
-namespace pybind11 {
-    template <typename itype>
-    struct polymorphic_type_hook<itype, detail::enable_if_t<std::is_base_of<Animal, itype>::value>>
-    {
-        static const void *get(const itype *src, const std::type_info*& type)
-        { type = src ? Animal::type_of_kind(src->kind) : nullptr; return src; }
-    };
-} // namespace pybind11
-
-TEST_SUBMODULE(tagbased_polymorphic, m) {
-    py::class_<Animal>(m, "Animal")
-        .def_readonly("name", &Animal::name);
-    py::class_<Dog, Animal>(m, "Dog")
-        .def(py::init<std::string>())
-        .def_readwrite("sound", &Dog::sound)
-        .def("bark", &Dog::bark);
-    py::class_<Labrador, Dog>(m, "Labrador")
-        .def(py::init<std::string, int>(), "name"_a, "excitement"_a = 9001)
-        .def_readwrite("excitement", &Labrador::excitement);
-    py::class_<Chihuahua, Dog>(m, "Chihuahua")
-        .def(py::init<std::string>())
-        .def("bark", &Chihuahua::bark);
-    py::class_<Cat, Animal>(m, "Cat")
-        .def(py::init<std::string>())
-        .def("purr", &Cat::purr);
-    py::class_<Panther, Cat>(m, "Panther")
-        .def(py::init<std::string>())
-        .def("purr", &Panther::purr);
-    m.def("create_zoo", &create_zoo);
-};

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

@@ -1,29 +0,0 @@
-# -*- coding: utf-8 -*-
-from pybind11_tests import tagbased_polymorphic as m
-
-
-def test_downcast():
-    zoo = m.create_zoo()
-    assert [type(animal) for animal in zoo] == [
-        m.Labrador,
-        m.Dog,
-        m.Chihuahua,
-        m.Cat,
-        m.Panther,
-    ]
-    assert [animal.name for animal in zoo] == [
-        "Fido",
-        "Ginger",
-        "Hertzl",
-        "Tiger",
-        "Leo",
-    ]
-    zoo[1].sound = "woooooo"
-    assert [dog.bark() for dog in zoo[:3]] == [
-        "Labrador Fido goes WOOF!",
-        "Dog Ginger goes woooooo",
-        "Chihuahua Hertzl goes iyiyiyiyiyi and runs in circles",
-    ]
-    assert [cat.purr() for cat in zoo[3:]] == ["mrowr", "mrrrRRRRRR"]
-    zoo[0].excitement -= 1000
-    assert zoo[0].excitement == 14000

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

@@ -1,66 +0,0 @@
-/*
-    tests/test_thread.cpp -- call pybind11 bound methods in threads
-
-    Copyright (c) 2021 Laramie Leavitt (Google LLC) <lar@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/cast.h>
-#include <pybind11/pybind11.h>
-
-#include <chrono>
-#include <thread>
-
-#include "pybind11_tests.h"
-
-namespace py = pybind11;
-
-namespace {
-
-struct IntStruct {
-    explicit IntStruct(int v) : value(v) {};
-    ~IntStruct() { value = -value; }
-    IntStruct(const IntStruct&) = default;
-    IntStruct& operator=(const IntStruct&) = default;
-
-    int value;
-};
-
-} // namespace
-
-TEST_SUBMODULE(thread, m) {
-
-    py::class_<IntStruct>(m, "IntStruct").def(py::init([](const int i) { return IntStruct(i); }));
-
-    // implicitly_convertible uses loader_life_support when an implicit
-    // conversion is required in order to lifetime extend the reference.
-    //
-    // This test should be run with ASAN for better effectiveness.
-    py::implicitly_convertible<int, IntStruct>();
-
-    m.def("test", [](int expected, const IntStruct &in) {
-        {
-            py::gil_scoped_release release;
-            std::this_thread::sleep_for(std::chrono::milliseconds(5));
-        }
-
-        if (in.value != expected) {
-            throw std::runtime_error("Value changed!!");
-        }
-    });
-
-    m.def(
-        "test_no_gil",
-        [](int expected, const IntStruct &in) {
-            std::this_thread::sleep_for(std::chrono::milliseconds(5));
-            if (in.value != expected) {
-                throw std::runtime_error("Value changed!!");
-            }
-        },
-        py::call_guard<py::gil_scoped_release>());
-
-    // NOTE: std::string_view also uses loader_life_support to ensure that
-    // the string contents remain alive, but that's a C++ 17 feature.
-}

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

@@ -1,44 +0,0 @@
-# -*- coding: utf-8 -*-
-
-import threading
-
-from pybind11_tests import thread as m
-
-
-class Thread(threading.Thread):
-    def __init__(self, fn):
-        super(Thread, self).__init__()
-        self.fn = fn
-        self.e = None
-
-    def run(self):
-        try:
-            for i in range(10):
-                self.fn(i, i)
-        except Exception as e:
-            self.e = e
-
-    def join(self):
-        super(Thread, self).join()
-        if self.e:
-            raise self.e
-
-
-def test_implicit_conversion():
-    a = Thread(m.test)
-    b = Thread(m.test)
-    c = Thread(m.test)
-    for x in [a, b, c]:
-        x.start()
-    for x in [c, b, a]:
-        x.join()
-
-
-def test_implicit_conversion_no_gil():
-    a = Thread(m.test_no_gil)
-    b = Thread(m.test_no_gil)
-    c = Thread(m.test_no_gil)
-    for x in [a, b, c]:
-        x.start()
-    for x in [c, b, a]:
-        x.join()

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

@@ -1,22 +0,0 @@
-/*
-    tests/test_class.cpp -- test py::class_ definitions and basic functionality
-
-    Copyright (c) 2019 Roland Dreier <roland.dreier@gmail.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"
-
-TEST_SUBMODULE(union_, m) {
-    union TestUnion {
-        int value_int;
-        unsigned value_uint;
-    };
-
-    py::class_<TestUnion>(m, "TestUnion")
-        .def(py::init<>())
-        .def_readonly("as_int", &TestUnion::value_int)
-        .def_readwrite("as_uint", &TestUnion::value_uint);
-}

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

@@ -1,9 +0,0 @@
-# -*- coding: utf-8 -*-
-from pybind11_tests import union_ as m
-
-
-def test_union():
-    instance = m.TestUnion()
-
-    instance.as_uint = 10
-    assert instance.as_int == 10