xcoll 0.3.3__py3-none-any.whl → 0.3.5__py3-none-any.whl

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/pybind11_tests.h

@@ -1,85 +0,0 @@
-#pragma once
-
-#include <pybind11/pybind11.h>
-#include <pybind11/eval.h>
-
-#if defined(_MSC_VER) && _MSC_VER < 1910
-// We get some really long type names here which causes MSVC 2015 to emit warnings
-#    pragma warning(                                                                              \
-        disable : 4503) // warning C4503: decorated name length exceeded, name was truncated
-#endif
-
-namespace py = pybind11;
-using namespace pybind11::literals;
-
-class test_initializer {
-    using Initializer = void (*)(py::module_ &);
-
-public:
-    explicit test_initializer(Initializer init);
-    test_initializer(const char *submodule_name, Initializer init);
-};
-
-#define TEST_SUBMODULE(name, variable)                                                            \
-    void test_submodule_##name(py::module_ &);                                                    \
-    test_initializer name(#name, test_submodule_##name);                                          \
-    void test_submodule_##name(py::module_ &(variable))
-
-/// Dummy type which is not exported anywhere -- something to trigger a conversion error
-struct UnregisteredType { };
-
-/// A user-defined type which is exported and can be used by any test
-class UserType {
-public:
-    UserType() = default;
-    explicit UserType(int i) : i(i) { }
-
-    int value() const { return i; }
-    void set(int set) { i = set; }
-
-private:
-    int i = -1;
-};
-
-/// Like UserType, but increments `value` on copy for quick reference vs. copy tests
-class IncType : public UserType {
-public:
-    using UserType::UserType;
-    IncType() = default;
-    IncType(const IncType &other) : IncType(other.value() + 1) { }
-    IncType(IncType &&) = delete;
-    IncType &operator=(const IncType &) = delete;
-    IncType &operator=(IncType &&) = delete;
-};
-
-/// A simple union for basic testing
-union IntFloat {
-    int i;
-    float f;
-};
-
-/// Custom cast-only type that casts to a string "rvalue" or "lvalue" depending on the cast context.
-/// Used to test recursive casters (e.g. std::tuple, stl containers).
-struct RValueCaster {};
-PYBIND11_NAMESPACE_BEGIN(pybind11)
-PYBIND11_NAMESPACE_BEGIN(detail)
-template<> class type_caster<RValueCaster> {
-public:
-    PYBIND11_TYPE_CASTER(RValueCaster, _("RValueCaster"));
-    static handle cast(RValueCaster &&, return_value_policy, handle) { return py::str("rvalue").release(); }
-    static handle cast(const RValueCaster &, return_value_policy, handle) { return py::str("lvalue").release(); }
-};
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(pybind11)
-
-template <typename F>
-void ignoreOldStyleInitWarnings(F &&body) {
-    py::exec(R"(
-    message = "pybind11-bound class '.+' is using an old-style placement-new '(?:__init__|__setstate__)' which has been deprecated"
-
-    import warnings
-    with warnings.catch_warnings():
-        warnings.filterwarnings("ignore", message=message, category=FutureWarning)
-        body()
-    )", py::dict(py::arg("body") = py::cpp_function(body)));
-}

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/pytest.ini

@@ -1,19 +0,0 @@
-[pytest]
-minversion = 3.1
-norecursedirs = test_* extra_*
-xfail_strict = True
-addopts =
-    # show summary of skipped tests
-    -rs
-    # capture only Python print and C++ py::print, but not C output (low-level Python errors)
-    --capture=sys
-filterwarnings =
-    # make warnings into errors but ignore certain third-party extension issues
-    error
-    # somehow, some DeprecationWarnings do not get turned into errors
-    always::DeprecationWarning
-    # importing scipy submodules on some version of Python
-    ignore::ImportWarning
-    # bogus numpy ABI warning (see numpy/#432)
-    ignore:.*numpy.dtype size changed.*:RuntimeWarning
-    ignore:.*numpy.ufunc size changed.*:RuntimeWarning

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/requirements.txt

@@ -1,12 +0,0 @@
---extra-index-url https://antocuni.github.io/pypy-wheels/manylinux2010/
-numpy==1.16.6; python_version<"3.6" and sys_platform!="win32"
-numpy==1.18.0; platform_python_implementation=="PyPy" and sys_platform=="darwin" and python_version>="3.6"
-numpy==1.19.3; (platform_python_implementation!="PyPy" or sys_platform=="linux") and python_version=="3.6"
-numpy==1.21.2; (platform_python_implementation!="PyPy" or sys_platform=="linux") and python_version>="3.7" and python_version<"3.10"
-numpy==1.21.2; platform_python_implementation!="PyPy" and sys_platform=="linux" and python_version=="3.10"
-pytest==4.6.9; python_version<"3.5"
-pytest==6.1.2; python_version=="3.5"
-pytest==6.2.4; python_version>="3.6"
-pytest-timeout
-scipy==1.2.3; (platform_python_implementation!="PyPy" or sys_platform=="linux") and python_version<"3.6"
-scipy==1.5.4; (platform_python_implementation!="PyPy" or sys_platform=="linux") and python_version>="3.6" and python_version<"3.10"

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

@@ -1,26 +0,0 @@
-/*
-    tests/test_async.cpp -- __await__ support
-
-    Copyright (c) 2019 Google Inc.
-
-    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(async_module, m) {
-    struct DoesNotSupportAsync {};
-    py::class_<DoesNotSupportAsync>(m, "DoesNotSupportAsync")
-        .def(py::init<>());
-    struct SupportsAsync {};
-    py::class_<SupportsAsync>(m, "SupportsAsync")
-        .def(py::init<>())
-        .def("__await__", [](const SupportsAsync& self) -> py::object {
-            static_cast<void>(self);
-            py::object loop = py::module_::import("asyncio.events").attr("get_event_loop")();
-            py::object f = loop.attr("create_future")();
-            f.attr("set_result")(5);
-            return f.attr("__await__")();
-        });
-}

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

@@ -1,25 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-asyncio = pytest.importorskip("asyncio")
-m = pytest.importorskip("pybind11_tests.async_module")
-
-
-@pytest.fixture
-def event_loop():
-    loop = asyncio.new_event_loop()
-    yield loop
-    loop.close()
-
-
-async def get_await_result(x):
-    return await x
-
-
-def test_await(event_loop):
-    assert 5 == event_loop.run_until_complete(get_await_result(m.SupportsAsync()))
-
-
-def test_await_missing(event_loop):
-    with pytest.raises(TypeError):
-        event_loop.run_until_complete(get_await_result(m.DoesNotSupportAsync()))

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

@@ -1,216 +0,0 @@
-/*
-    tests/test_buffers.cpp -- supporting Pythons' buffer protocol
-
-    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/stl.h>
-
-TEST_SUBMODULE(buffers, m) {
-    // test_from_python / test_to_python:
-    class Matrix {
-    public:
-        Matrix(py::ssize_t rows, py::ssize_t cols) : m_rows(rows), m_cols(cols) {
-            print_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
-            m_data = new float[(size_t) (rows*cols)];
-            memset(m_data, 0, sizeof(float) * (size_t) (rows * cols));
-        }
-
-        Matrix(const Matrix &s) : m_rows(s.m_rows), m_cols(s.m_cols) {
-            print_copy_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
-            m_data = new float[(size_t) (m_rows * m_cols)];
-            memcpy(m_data, s.m_data, sizeof(float) * (size_t) (m_rows * m_cols));
-        }
-
-        Matrix(Matrix &&s) noexcept : m_rows(s.m_rows), m_cols(s.m_cols), m_data(s.m_data) {
-            print_move_created(this);
-            s.m_rows = 0;
-            s.m_cols = 0;
-            s.m_data = nullptr;
-        }
-
-        ~Matrix() {
-            print_destroyed(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
-            delete[] m_data;
-        }
-
-        Matrix &operator=(const Matrix &s) {
-            if (this == &s) {
-                return *this;
-            }
-            print_copy_assigned(this,
-                                std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
-            delete[] m_data;
-            m_rows = s.m_rows;
-            m_cols = s.m_cols;
-            m_data = new float[(size_t) (m_rows * m_cols)];
-            memcpy(m_data, s.m_data, sizeof(float) * (size_t) (m_rows * m_cols));
-            return *this;
-        }
-
-        Matrix &operator=(Matrix &&s) noexcept {
-            print_move_assigned(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
-            if (&s != this) {
-                delete[] m_data;
-                m_rows = s.m_rows; m_cols = s.m_cols; m_data = s.m_data;
-                s.m_rows = 0; s.m_cols = 0; s.m_data = nullptr;
-            }
-            return *this;
-        }
-
-        float operator()(py::ssize_t i, py::ssize_t j) const {
-            return m_data[(size_t) (i*m_cols + j)];
-        }
-
-        float &operator()(py::ssize_t i, py::ssize_t j) {
-            return m_data[(size_t) (i*m_cols + j)];
-        }
-
-        float *data() { return m_data; }
-
-        py::ssize_t rows() const { return m_rows; }
-        py::ssize_t cols() const { return m_cols; }
-    private:
-        py::ssize_t m_rows;
-        py::ssize_t m_cols;
-        float *m_data;
-    };
-    py::class_<Matrix>(m, "Matrix", py::buffer_protocol())
-        .def(py::init<py::ssize_t, py::ssize_t>())
-        /// Construct from a buffer
-        .def(py::init([](const py::buffer &b) {
-            py::buffer_info info = b.request();
-            if (info.format != py::format_descriptor<float>::format() || info.ndim != 2)
-                throw std::runtime_error("Incompatible buffer format!");
-
-            auto v = new Matrix(info.shape[0], info.shape[1]);
-            memcpy(v->data(), info.ptr, sizeof(float) * (size_t) (v->rows() * v->cols()));
-            return v;
-        }))
-
-        .def("rows", &Matrix::rows)
-        .def("cols", &Matrix::cols)
-
-        /// Bare bones interface
-        .def("__getitem__",
-             [](const Matrix &m, std::pair<py::ssize_t, py::ssize_t> i) {
-                 if (i.first >= m.rows() || i.second >= m.cols())
-                     throw py::index_error();
-                 return m(i.first, i.second);
-             })
-        .def("__setitem__",
-             [](Matrix &m, std::pair<py::ssize_t, py::ssize_t> i, float v) {
-                 if (i.first >= m.rows() || i.second >= m.cols())
-                     throw py::index_error();
-                 m(i.first, i.second) = v;
-             })
-        /// Provide buffer access
-        .def_buffer([](Matrix &m) -> py::buffer_info {
-            return py::buffer_info(
-                m.data(),                               /* Pointer to buffer */
-                { m.rows(), m.cols() },                 /* Buffer dimensions */
-                { sizeof(float) * size_t(m.cols()),     /* Strides (in bytes) for each index */
-                  sizeof(float) }
-            );
-        });
-
-    // test_inherited_protocol
-    class SquareMatrix : public Matrix {
-    public:
-        explicit SquareMatrix(py::ssize_t n) : Matrix(n, n) {}
-    };
-    // Derived classes inherit the buffer protocol and the buffer access function
-    py::class_<SquareMatrix, Matrix>(m, "SquareMatrix")
-        .def(py::init<py::ssize_t>());
-
-
-    // test_pointer_to_member_fn
-    // Tests that passing a pointer to member to the base class works in
-    // the derived class.
-    struct Buffer {
-        int32_t value = 0;
-
-        py::buffer_info get_buffer_info() {
-            return py::buffer_info(&value, sizeof(value),
-                                   py::format_descriptor<int32_t>::format(), 1);
-        }
-    };
-    py::class_<Buffer>(m, "Buffer", py::buffer_protocol())
-        .def(py::init<>())
-        .def_readwrite("value", &Buffer::value)
-        .def_buffer(&Buffer::get_buffer_info);
-
-
-    class ConstBuffer {
-        std::unique_ptr<int32_t> value;
-
-    public:
-        int32_t get_value() const { return *value; }
-        void set_value(int32_t v) { *value = v; }
-
-        py::buffer_info get_buffer_info() const {
-            return py::buffer_info(value.get(), sizeof(*value),
-                                   py::format_descriptor<int32_t>::format(), 1);
-        }
-
-        ConstBuffer() : value(new int32_t{0}) {}
-    };
-    py::class_<ConstBuffer>(m, "ConstBuffer", py::buffer_protocol())
-        .def(py::init<>())
-        .def_property("value", &ConstBuffer::get_value, &ConstBuffer::set_value)
-        .def_buffer(&ConstBuffer::get_buffer_info);
-
-    struct DerivedBuffer : public Buffer { };
-    py::class_<DerivedBuffer>(m, "DerivedBuffer", py::buffer_protocol())
-        .def(py::init<>())
-        .def_readwrite("value", (int32_t DerivedBuffer::*) &DerivedBuffer::value)
-        .def_buffer(&DerivedBuffer::get_buffer_info);
-
-    struct BufferReadOnly {
-        const uint8_t value = 0;
-        explicit BufferReadOnly(uint8_t value) : value(value) {}
-
-        py::buffer_info get_buffer_info() {
-            return py::buffer_info(&value, 1);
-        }
-    };
-    py::class_<BufferReadOnly>(m, "BufferReadOnly", py::buffer_protocol())
-        .def(py::init<uint8_t>())
-        .def_buffer(&BufferReadOnly::get_buffer_info);
-
-    struct BufferReadOnlySelect {
-        uint8_t value = 0;
-        bool readonly = false;
-
-        py::buffer_info get_buffer_info() {
-            return py::buffer_info(&value, 1, readonly);
-        }
-    };
-    py::class_<BufferReadOnlySelect>(m, "BufferReadOnlySelect", py::buffer_protocol())
-        .def(py::init<>())
-        .def_readwrite("value", &BufferReadOnlySelect::value)
-        .def_readwrite("readonly", &BufferReadOnlySelect::readonly)
-        .def_buffer(&BufferReadOnlySelect::get_buffer_info);
-
-    // Expose buffer_info for testing.
-    py::class_<py::buffer_info>(m, "buffer_info")
-        .def(py::init<>())
-        .def_readonly("itemsize", &py::buffer_info::itemsize)
-        .def_readonly("size", &py::buffer_info::size)
-        .def_readonly("format", &py::buffer_info::format)
-        .def_readonly("ndim", &py::buffer_info::ndim)
-        .def_readonly("shape", &py::buffer_info::shape)
-        .def_readonly("strides", &py::buffer_info::strides)
-        .def_readonly("readonly", &py::buffer_info::readonly)
-        .def("__repr__", [](py::handle self) {
-             return py::str("itemsize={0.itemsize!r}, size={0.size!r}, format={0.format!r}, ndim={0.ndim!r}, shape={0.shape!r}, strides={0.strides!r}, readonly={0.readonly!r}").format(self);
-        })
-        ;
-
-    m.def("get_buffer_info", [](const py::buffer &buffer) { return buffer.request(); });
-}

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

@@ -1,163 +0,0 @@
-# -*- coding: utf-8 -*-
-import ctypes
-import io
-import struct
-
-import pytest
-
-import env
-from pybind11_tests import ConstructorStats
-from pybind11_tests import buffers as m
-
-np = pytest.importorskip("numpy")
-
-
-def test_from_python():
-    with pytest.raises(RuntimeError) as excinfo:
-        m.Matrix(np.array([1, 2, 3]))  # trying to assign a 1D array
-    assert str(excinfo.value) == "Incompatible buffer format!"
-
-    m3 = np.array([[1, 2, 3], [4, 5, 6]]).astype(np.float32)
-    m4 = m.Matrix(m3)
-
-    for i in range(m4.rows()):
-        for j in range(m4.cols()):
-            assert m3[i, j] == m4[i, j]
-
-    cstats = ConstructorStats.get(m.Matrix)
-    assert cstats.alive() == 1
-    del m3, m4
-    assert cstats.alive() == 0
-    assert cstats.values() == ["2x3 matrix"]
-    assert cstats.copy_constructions == 0
-    # assert cstats.move_constructions >= 0  # Don't invoke any
-    assert cstats.copy_assignments == 0
-    assert cstats.move_assignments == 0
-
-
-# https://foss.heptapod.net/pypy/pypy/-/issues/2444
-def test_to_python():
-    mat = m.Matrix(5, 4)
-    assert memoryview(mat).shape == (5, 4)
-
-    assert mat[2, 3] == 0
-    mat[2, 3] = 4.0
-    mat[3, 2] = 7.0
-    assert mat[2, 3] == 4
-    assert mat[3, 2] == 7
-    assert struct.unpack_from("f", mat, (3 * 4 + 2) * 4) == (7,)
-    assert struct.unpack_from("f", mat, (2 * 4 + 3) * 4) == (4,)
-
-    mat2 = np.array(mat, copy=False)
-    assert mat2.shape == (5, 4)
-    assert abs(mat2).sum() == 11
-    assert mat2[2, 3] == 4 and mat2[3, 2] == 7
-    mat2[2, 3] = 5
-    assert mat2[2, 3] == 5
-
-    cstats = ConstructorStats.get(m.Matrix)
-    assert cstats.alive() == 1
-    del mat
-    pytest.gc_collect()
-    assert cstats.alive() == 1
-    del mat2  # holds a mat reference
-    pytest.gc_collect()
-    assert cstats.alive() == 0
-    assert cstats.values() == ["5x4 matrix"]
-    assert cstats.copy_constructions == 0
-    # assert cstats.move_constructions >= 0  # Don't invoke any
-    assert cstats.copy_assignments == 0
-    assert cstats.move_assignments == 0
-
-
-def test_inherited_protocol():
-    """SquareMatrix is derived from Matrix and inherits the buffer protocol"""
-
-    matrix = m.SquareMatrix(5)
-    assert memoryview(matrix).shape == (5, 5)
-    assert np.asarray(matrix).shape == (5, 5)
-
-
-def test_pointer_to_member_fn():
-    for cls in [m.Buffer, m.ConstBuffer, m.DerivedBuffer]:
-        buf = cls()
-        buf.value = 0x12345678
-        value = struct.unpack("i", bytearray(buf))[0]
-        assert value == 0x12345678
-
-
-def test_readonly_buffer():
-    buf = m.BufferReadOnly(0x64)
-    view = memoryview(buf)
-    assert view[0] == b"d" if env.PY2 else 0x64
-    assert view.readonly
-    with pytest.raises(TypeError):
-        view[0] = b"\0" if env.PY2 else 0
-
-
-def test_selective_readonly_buffer():
-    buf = m.BufferReadOnlySelect()
-
-    memoryview(buf)[0] = b"d" if env.PY2 else 0x64
-    assert buf.value == 0x64
-
-    io.BytesIO(b"A").readinto(buf)
-    assert buf.value == ord(b"A")
-
-    buf.readonly = True
-    with pytest.raises(TypeError):
-        memoryview(buf)[0] = b"\0" if env.PY2 else 0
-    with pytest.raises(TypeError):
-        io.BytesIO(b"1").readinto(buf)
-
-
-def test_ctypes_array_1d():
-    char1d = (ctypes.c_char * 10)()
-    int1d = (ctypes.c_int * 15)()
-    long1d = (ctypes.c_long * 7)()
-
-    for carray in (char1d, int1d, long1d):
-        info = m.get_buffer_info(carray)
-        assert info.itemsize == ctypes.sizeof(carray._type_)
-        assert info.size == len(carray)
-        assert info.ndim == 1
-        assert info.shape == [info.size]
-        assert info.strides == [info.itemsize]
-        assert not info.readonly
-
-
-def test_ctypes_array_2d():
-    char2d = ((ctypes.c_char * 10) * 4)()
-    int2d = ((ctypes.c_int * 15) * 3)()
-    long2d = ((ctypes.c_long * 7) * 2)()
-
-    for carray in (char2d, int2d, long2d):
-        info = m.get_buffer_info(carray)
-        assert info.itemsize == ctypes.sizeof(carray[0]._type_)
-        assert info.size == len(carray) * len(carray[0])
-        assert info.ndim == 2
-        assert info.shape == [len(carray), len(carray[0])]
-        assert info.strides == [info.itemsize * len(carray[0]), info.itemsize]
-        assert not info.readonly
-
-
-@pytest.mark.skipif(
-    "env.PYPY and env.PY2", reason="PyPy2 bytes buffer not reported as readonly"
-)
-def test_ctypes_from_buffer():
-    test_pystr = b"0123456789"
-    for pyarray in (test_pystr, bytearray(test_pystr)):
-        pyinfo = m.get_buffer_info(pyarray)
-
-        if pyinfo.readonly:
-            cbytes = (ctypes.c_char * len(pyarray)).from_buffer_copy(pyarray)
-            cinfo = m.get_buffer_info(cbytes)
-        else:
-            cbytes = (ctypes.c_char * len(pyarray)).from_buffer(pyarray)
-            cinfo = m.get_buffer_info(cbytes)
-
-        assert cinfo.size == pyinfo.size
-        assert cinfo.ndim == pyinfo.ndim
-        assert cinfo.shape == pyinfo.shape
-        assert cinfo.strides == pyinfo.strides
-        assert not cinfo.readonly