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

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

@@ -1,146 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-from pybind11_tests import ConstructorStats
-from pybind11_tests import operators as m
-
-
-def test_operator_overloading():
-    v1 = m.Vector2(1, 2)
-    v2 = m.Vector(3, -1)
-    v3 = m.Vector2(1, 2)  # Same value as v1, but different instance.
-    assert v1 is not v3
-
-    assert str(v1) == "[1.000000, 2.000000]"
-    assert str(v2) == "[3.000000, -1.000000]"
-
-    assert str(-v2) == "[-3.000000, 1.000000]"
-
-    assert str(v1 + v2) == "[4.000000, 1.000000]"
-    assert str(v1 - v2) == "[-2.000000, 3.000000]"
-    assert str(v1 - 8) == "[-7.000000, -6.000000]"
-    assert str(v1 + 8) == "[9.000000, 10.000000]"
-    assert str(v1 * 8) == "[8.000000, 16.000000]"
-    assert str(v1 / 8) == "[0.125000, 0.250000]"
-    assert str(8 - v1) == "[7.000000, 6.000000]"
-    assert str(8 + v1) == "[9.000000, 10.000000]"
-    assert str(8 * v1) == "[8.000000, 16.000000]"
-    assert str(8 / v1) == "[8.000000, 4.000000]"
-    assert str(v1 * v2) == "[3.000000, -2.000000]"
-    assert str(v2 / v1) == "[3.000000, -0.500000]"
-
-    assert v1 == v3
-    assert v1 != v2
-    assert hash(v1) == 4
-    # TODO(eric.cousineau): Make this work.
-    # assert abs(v1) == "abs(Vector2)"
-
-    v1 += 2 * v2
-    assert str(v1) == "[7.000000, 0.000000]"
-    v1 -= v2
-    assert str(v1) == "[4.000000, 1.000000]"
-    v1 *= 2
-    assert str(v1) == "[8.000000, 2.000000]"
-    v1 /= 16
-    assert str(v1) == "[0.500000, 0.125000]"
-    v1 *= v2
-    assert str(v1) == "[1.500000, -0.125000]"
-    v2 /= v1
-    assert str(v2) == "[2.000000, 8.000000]"
-
-    cstats = ConstructorStats.get(m.Vector2)
-    assert cstats.alive() == 3
-    del v1
-    assert cstats.alive() == 2
-    del v2
-    assert cstats.alive() == 1
-    del v3
-    assert cstats.alive() == 0
-    assert cstats.values() == [
-        "[1.000000, 2.000000]",
-        "[3.000000, -1.000000]",
-        "[1.000000, 2.000000]",
-        "[-3.000000, 1.000000]",
-        "[4.000000, 1.000000]",
-        "[-2.000000, 3.000000]",
-        "[-7.000000, -6.000000]",
-        "[9.000000, 10.000000]",
-        "[8.000000, 16.000000]",
-        "[0.125000, 0.250000]",
-        "[7.000000, 6.000000]",
-        "[9.000000, 10.000000]",
-        "[8.000000, 16.000000]",
-        "[8.000000, 4.000000]",
-        "[3.000000, -2.000000]",
-        "[3.000000, -0.500000]",
-        "[6.000000, -2.000000]",
-    ]
-    assert cstats.default_constructions == 0
-    assert cstats.copy_constructions == 0
-    assert cstats.move_constructions >= 10
-    assert cstats.copy_assignments == 0
-    assert cstats.move_assignments == 0
-
-
-def test_operators_notimplemented():
-    """#393: need to return NotSupported to ensure correct arithmetic operator behavior"""
-
-    c1, c2 = m.C1(), m.C2()
-    assert c1 + c1 == 11
-    assert c2 + c2 == 22
-    assert c2 + c1 == 21
-    assert c1 + c2 == 12
-
-
-def test_nested():
-    """#328: first member in a class can't be used in operators"""
-
-    a = m.NestA()
-    b = m.NestB()
-    c = m.NestC()
-
-    a += 10
-    assert m.get_NestA(a) == 13
-    b.a += 100
-    assert m.get_NestA(b.a) == 103
-    c.b.a += 1000
-    assert m.get_NestA(c.b.a) == 1003
-    b -= 1
-    assert m.get_NestB(b) == 3
-    c.b -= 3
-    assert m.get_NestB(c.b) == 1
-    c *= 7
-    assert m.get_NestC(c) == 35
-
-    abase = a.as_base()
-    assert abase.value == -2
-    a.as_base().value += 44
-    assert abase.value == 42
-    assert c.b.a.as_base().value == -2
-    c.b.a.as_base().value += 44
-    assert c.b.a.as_base().value == 42
-
-    del c
-    pytest.gc_collect()
-    del a  # Shouldn't delete while abase is still alive
-    pytest.gc_collect()
-
-    assert abase.value == 42
-    del abase, b
-    pytest.gc_collect()
-
-
-def test_overriding_eq_reset_hash():
-
-    assert m.Comparable(15) is not m.Comparable(15)
-    assert m.Comparable(15) == m.Comparable(15)
-
-    with pytest.raises(TypeError):
-        hash(m.Comparable(15))  # TypeError: unhashable type: 'm.Comparable'
-
-    for hashable in (m.Hashable, m.Hashable2):
-        assert hashable(15) is not hashable(15)
-        assert hashable(15) == hashable(15)
-
-        assert hash(hashable(15)) == 15
-        assert hash(hashable(15)) == hash(hashable(15))

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

@@ -1,189 +0,0 @@
-// clang-format off
-/*
-    tests/test_pickling.cpp -- pickle support
-
-    Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-    Copyright (c) 2021 The Pybind Development Team.
-
-    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"
-
-// clang-format on
-
-#include <memory>
-#include <stdexcept>
-#include <utility>
-
-namespace exercise_trampoline {
-
-struct SimpleBase {
-    int num               = 0;
-    virtual ~SimpleBase() = default;
-
-    // For compatibility with old clang versions:
-    SimpleBase()                   = default;
-    SimpleBase(const SimpleBase &) = default;
-};
-
-struct SimpleBaseTrampoline : SimpleBase {};
-
-struct SimpleCppDerived : SimpleBase {};
-
-void wrap(py::module m) {
-    py::class_<SimpleBase, SimpleBaseTrampoline>(m, "SimpleBase")
-        .def(py::init<>())
-        .def_readwrite("num", &SimpleBase::num)
-        .def(py::pickle(
-            [](const py::object &self) {
-                py::dict d;
-                if (py::hasattr(self, "__dict__"))
-                    d = self.attr("__dict__");
-                return py::make_tuple(self.attr("num"), d);
-            },
-            [](const py::tuple &t) {
-                if (t.size() != 2)
-                    throw std::runtime_error("Invalid state!");
-                auto cpp_state = std::unique_ptr<SimpleBase>(new SimpleBaseTrampoline);
-                cpp_state->num = t[0].cast<int>();
-                auto py_state  = t[1].cast<py::dict>();
-                return std::make_pair(std::move(cpp_state), py_state);
-            }));
-
-    m.def("make_SimpleCppDerivedAsBase",
-          []() { return std::unique_ptr<SimpleBase>(new SimpleCppDerived); });
-    m.def("check_dynamic_cast_SimpleCppDerived", [](const SimpleBase *base_ptr) {
-        return dynamic_cast<const SimpleCppDerived *>(base_ptr) != nullptr;
-    });
-}
-
-} // namespace exercise_trampoline
-
-// clang-format off
-
-TEST_SUBMODULE(pickling, m) {
-    // test_roundtrip
-    class Pickleable {
-    public:
-        explicit Pickleable(const std::string &value) : m_value(value) { }
-        const std::string &value() const { return m_value; }
-
-        void setExtra1(int extra1) { m_extra1 = extra1; }
-        void setExtra2(int extra2) { m_extra2 = extra2; }
-        int extra1() const { return m_extra1; }
-        int extra2() const { return m_extra2; }
-    private:
-        std::string m_value;
-        int m_extra1 = 0;
-        int m_extra2 = 0;
-    };
-
-    class PickleableNew : public Pickleable {
-    public:
-        using Pickleable::Pickleable;
-    };
-
-    py::class_<Pickleable> pyPickleable(m, "Pickleable");
-    pyPickleable
-        .def(py::init<std::string>())
-        .def("value", &Pickleable::value)
-        .def("extra1", &Pickleable::extra1)
-        .def("extra2", &Pickleable::extra2)
-        .def("setExtra1", &Pickleable::setExtra1)
-        .def("setExtra2", &Pickleable::setExtra2)
-        // For details on the methods below, refer to
-        // http://docs.python.org/3/library/pickle.html#pickling-class-instances
-        .def("__getstate__", [](const Pickleable &p) {
-            /* Return a tuple that fully encodes the state of the object */
-            return py::make_tuple(p.value(), p.extra1(), p.extra2());
-        });
-    ignoreOldStyleInitWarnings([&pyPickleable]() {
-        pyPickleable.def("__setstate__", [](Pickleable &p, const py::tuple &t) {
-            if (t.size() != 3)
-                throw std::runtime_error("Invalid state!");
-            /* Invoke the constructor (need to use in-place version) */
-            new (&p) Pickleable(t[0].cast<std::string>());
-
-            /* Assign any additional state */
-            p.setExtra1(t[1].cast<int>());
-            p.setExtra2(t[2].cast<int>());
-        });
-    });
-
-    py::class_<PickleableNew, Pickleable>(m, "PickleableNew")
-        .def(py::init<std::string>())
-        .def(py::pickle(
-            [](const PickleableNew &p) {
-                return py::make_tuple(p.value(), p.extra1(), p.extra2());
-            },
-            [](const py::tuple &t) {
-                if (t.size() != 3)
-                    throw std::runtime_error("Invalid state!");
-                auto p = PickleableNew(t[0].cast<std::string>());
-
-                p.setExtra1(t[1].cast<int>());
-                p.setExtra2(t[2].cast<int>());
-                return p;
-            }));
-
-#if !defined(PYPY_VERSION)
-    // test_roundtrip_with_dict
-    class PickleableWithDict {
-    public:
-        explicit PickleableWithDict(const std::string &value) : value(value) { }
-
-        std::string value;
-        int extra;
-    };
-
-    class PickleableWithDictNew : public PickleableWithDict {
-    public:
-        using PickleableWithDict::PickleableWithDict;
-    };
-
-    py::class_<PickleableWithDict> pyPickleableWithDict(m, "PickleableWithDict", py::dynamic_attr());
-    pyPickleableWithDict.def(py::init<std::string>())
-        .def_readwrite("value", &PickleableWithDict::value)
-        .def_readwrite("extra", &PickleableWithDict::extra)
-        .def("__getstate__", [](const py::object &self) {
-            /* Also include __dict__ in state */
-            return py::make_tuple(self.attr("value"), self.attr("extra"), self.attr("__dict__"));
-        });
-    ignoreOldStyleInitWarnings([&pyPickleableWithDict]() {
-        pyPickleableWithDict.def("__setstate__", [](const py::object &self, const py::tuple &t) {
-            if (t.size() != 3)
-                throw std::runtime_error("Invalid state!");
-            /* Cast and construct */
-            auto &p = self.cast<PickleableWithDict &>();
-            new (&p) PickleableWithDict(t[0].cast<std::string>());
-
-            /* Assign C++ state */
-            p.extra = t[1].cast<int>();
-
-            /* Assign Python state */
-            self.attr("__dict__") = t[2];
-        });
-    });
-
-    py::class_<PickleableWithDictNew, PickleableWithDict>(m, "PickleableWithDictNew")
-        .def(py::init<std::string>())
-        .def(py::pickle(
-            [](const py::object &self) {
-                return py::make_tuple(self.attr("value"), self.attr("extra"), self.attr("__dict__"));
-            },
-            [](const py::tuple &t) {
-                if (t.size() != 3)
-                    throw std::runtime_error("Invalid state!");
-
-                auto cpp_state = PickleableWithDictNew(t[0].cast<std::string>());
-                cpp_state.extra = t[1].cast<int>();
-
-                auto py_state = t[2].cast<py::dict>();
-                return std::make_pair(cpp_state, py_state);
-            }));
-#endif
-
-    exercise_trampoline::wrap(m);
-}

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

@@ -1,82 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-import env
-from pybind11_tests import pickling as m
-
-try:
-    import cPickle as pickle  # Use cPickle on Python 2.7
-except ImportError:
-    import pickle
-
-
-@pytest.mark.parametrize("cls_name", ["Pickleable", "PickleableNew"])
-def test_roundtrip(cls_name):
-    cls = getattr(m, cls_name)
-    p = cls("test_value")
-    p.setExtra1(15)
-    p.setExtra2(48)
-
-    data = pickle.dumps(p, 2)  # Must use pickle protocol >= 2
-    p2 = pickle.loads(data)
-    assert p2.value() == p.value()
-    assert p2.extra1() == p.extra1()
-    assert p2.extra2() == p.extra2()
-
-
-@pytest.mark.xfail("env.PYPY")
-@pytest.mark.parametrize("cls_name", ["PickleableWithDict", "PickleableWithDictNew"])
-def test_roundtrip_with_dict(cls_name):
-    cls = getattr(m, cls_name)
-    p = cls("test_value")
-    p.extra = 15
-    p.dynamic = "Attribute"
-
-    data = pickle.dumps(p, pickle.HIGHEST_PROTOCOL)
-    p2 = pickle.loads(data)
-    assert p2.value == p.value
-    assert p2.extra == p.extra
-    assert p2.dynamic == p.dynamic
-
-
-def test_enum_pickle():
-    from pybind11_tests import enums as e
-
-    data = pickle.dumps(e.EOne, 2)
-    assert e.EOne == pickle.loads(data)
-
-
-#
-# exercise_trampoline
-#
-class SimplePyDerived(m.SimpleBase):
-    pass
-
-
-def test_roundtrip_simple_py_derived():
-    p = SimplePyDerived()
-    p.num = 202
-    p.stored_in_dict = 303
-    data = pickle.dumps(p, pickle.HIGHEST_PROTOCOL)
-    p2 = pickle.loads(data)
-    assert isinstance(p2, SimplePyDerived)
-    assert p2.num == 202
-    assert p2.stored_in_dict == 303
-
-
-def test_roundtrip_simple_cpp_derived():
-    p = m.make_SimpleCppDerivedAsBase()
-    assert m.check_dynamic_cast_SimpleCppDerived(p)
-    p.num = 404
-    if not env.PYPY:
-        # To ensure that this unit test is not accidentally invalidated.
-        with pytest.raises(AttributeError):
-            # Mimics the `setstate` C++ implementation.
-            setattr(p, "__dict__", {})  # noqa: B010
-    data = pickle.dumps(p, pickle.HIGHEST_PROTOCOL)
-    p2 = pickle.loads(data)
-    assert isinstance(p2, m.SimpleBase)
-    assert p2.num == 404
-    # Issue #3062: pickleable base C++ classes can incur object slicing
-    #              if derived typeid is not registered with pybind11
-    assert not m.check_dynamic_cast_SimpleCppDerived(p2)