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

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/extra_setuptools/test_setuphelper.py

@@ -1,143 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-import subprocess
-import sys
-from textwrap import dedent
-
-import pytest
-
-DIR = os.path.abspath(os.path.dirname(__file__))
-MAIN_DIR = os.path.dirname(os.path.dirname(DIR))
-
-
-@pytest.mark.parametrize("parallel", [False, True])
-@pytest.mark.parametrize("std", [11, 0])
-def test_simple_setup_py(monkeypatch, tmpdir, parallel, std):
-    monkeypatch.chdir(tmpdir)
-    monkeypatch.syspath_prepend(MAIN_DIR)
-
-    (tmpdir / "setup.py").write_text(
-        dedent(
-            u"""\
-            import sys
-            sys.path.append({MAIN_DIR!r})
-
-            from setuptools import setup, Extension
-            from pybind11.setup_helpers import build_ext, Pybind11Extension
-
-            std = {std}
-
-            ext_modules = [
-                Pybind11Extension(
-                    "simple_setup",
-                    sorted(["main.cpp"]),
-                    cxx_std=std,
-                ),
-            ]
-
-            cmdclass = dict()
-            if std == 0:
-                cmdclass["build_ext"] = build_ext
-
-
-            parallel = {parallel}
-            if parallel:
-                from pybind11.setup_helpers import ParallelCompile
-                ParallelCompile().install()
-
-            setup(
-                name="simple_setup_package",
-                cmdclass=cmdclass,
-                ext_modules=ext_modules,
-            )
-            """
-        ).format(MAIN_DIR=MAIN_DIR, std=std, parallel=parallel),
-        encoding="ascii",
-    )
-
-    (tmpdir / "main.cpp").write_text(
-        dedent(
-            u"""\
-            #include <pybind11/pybind11.h>
-
-            int f(int x) {
-                return x * 3;
-            }
-            PYBIND11_MODULE(simple_setup, m) {
-                m.def("f", &f);
-            }
-            """
-        ),
-        encoding="ascii",
-    )
-
-    subprocess.check_call(
-        [sys.executable, "setup.py", "build_ext", "--inplace"],
-        stdout=sys.stdout,
-        stderr=sys.stderr,
-    )
-
-    # Debug helper printout, normally hidden
-    for item in tmpdir.listdir():
-        print(item.basename)
-
-    assert (
-        len([f for f in tmpdir.listdir() if f.basename.startswith("simple_setup")]) == 1
-    )
-    assert len(list(tmpdir.listdir())) == 4  # two files + output + build_dir
-
-    (tmpdir / "test.py").write_text(
-        dedent(
-            u"""\
-            import simple_setup
-            assert simple_setup.f(3) == 9
-            """
-        ),
-        encoding="ascii",
-    )
-
-    subprocess.check_call(
-        [sys.executable, "test.py"], stdout=sys.stdout, stderr=sys.stderr
-    )
-
-
-def test_intree_extensions(monkeypatch, tmpdir):
-    monkeypatch.syspath_prepend(MAIN_DIR)
-
-    from pybind11.setup_helpers import intree_extensions
-
-    monkeypatch.chdir(tmpdir)
-    root = tmpdir
-    root.ensure_dir()
-    subdir = root / "dir"
-    subdir.ensure_dir()
-    src = subdir / "ext.cpp"
-    src.ensure()
-    (ext,) = intree_extensions([src.relto(tmpdir)])
-    assert ext.name == "ext"
-    subdir.ensure("__init__.py")
-    (ext,) = intree_extensions([src.relto(tmpdir)])
-    assert ext.name == "dir.ext"
-
-
-def test_intree_extensions_package_dir(monkeypatch, tmpdir):
-    monkeypatch.syspath_prepend(MAIN_DIR)
-
-    from pybind11.setup_helpers import intree_extensions
-
-    monkeypatch.chdir(tmpdir)
-    root = tmpdir / "src"
-    root.ensure_dir()
-    subdir = root / "dir"
-    subdir.ensure_dir()
-    src = subdir / "ext.cpp"
-    src.ensure()
-    (ext,) = intree_extensions([src.relto(tmpdir)], package_dir={"": "src"})
-    assert ext.name == "dir.ext"
-    (ext,) = intree_extensions([src.relto(tmpdir)], package_dir={"foo": "src"})
-    assert ext.name == "foo.dir.ext"
-    subdir.ensure("__init__.py")
-    (ext,) = intree_extensions([src.relto(tmpdir)], package_dir={"": "src"})
-    assert ext.name == "dir.ext"
-    (ext,) = intree_extensions([src.relto(tmpdir)], package_dir={"foo": "src"})
-    assert ext.name == "foo.dir.ext"

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

@@ -1,85 +0,0 @@
-#pragma once
-#include <utility>
-
-#include "pybind11_tests.h"
-
-/// Simple class used to test py::local:
-template <int> class LocalBase {
-public:
-    explicit LocalBase(int i) : i(i) { }
-    int i = -1;
-};
-
-/// Registered with py::module_local in both main and secondary modules:
-using LocalType = LocalBase<0>;
-/// Registered without py::module_local in both modules:
-using NonLocalType = LocalBase<1>;
-/// A second non-local type (for stl_bind tests):
-using NonLocal2 = LocalBase<2>;
-/// Tests within-module, different-compilation-unit local definition conflict:
-using LocalExternal = LocalBase<3>;
-/// Mixed: registered local first, then global
-using MixedLocalGlobal = LocalBase<4>;
-/// Mixed: global first, then local
-using MixedGlobalLocal = LocalBase<5>;
-
-/// Registered with py::module_local only in the secondary module:
-using ExternalType1 = LocalBase<6>;
-using ExternalType2 = LocalBase<7>;
-
-using LocalVec = std::vector<LocalType>;
-using LocalVec2 = std::vector<NonLocal2>;
-using LocalMap = std::unordered_map<std::string, LocalType>;
-using NonLocalVec = std::vector<NonLocalType>;
-using NonLocalVec2 = std::vector<NonLocal2>;
-using NonLocalMap = std::unordered_map<std::string, NonLocalType>;
-using NonLocalMap2 = std::unordered_map<std::string, uint8_t>;
-
-
-// Exception that will be caught via the module local translator.
-class LocalException : public std::exception {
-public:
-    explicit LocalException(const char * m) : message{m} {}
-    const char * what() const noexcept override {return message.c_str();}
-private:
-    std::string message = "";
-};
-
-// Exception that will be registered with register_local_exception_translator
-class LocalSimpleException : public std::exception {
-public:
-    explicit LocalSimpleException(const char * m) : message{m} {}
-    const char * what() const noexcept override {return message.c_str();}
-private:
-    std::string message = "";
-};
-
-PYBIND11_MAKE_OPAQUE(LocalVec);
-PYBIND11_MAKE_OPAQUE(LocalVec2);
-PYBIND11_MAKE_OPAQUE(LocalMap);
-PYBIND11_MAKE_OPAQUE(NonLocalVec);
-//PYBIND11_MAKE_OPAQUE(NonLocalVec2); // same type as LocalVec2
-PYBIND11_MAKE_OPAQUE(NonLocalMap);
-PYBIND11_MAKE_OPAQUE(NonLocalMap2);
-
-
-// Simple bindings (used with the above):
-template <typename T, int Adjust = 0, typename... Args>
-py::class_<T> bind_local(Args && ...args) {
-    return py::class_<T>(std::forward<Args>(args)...)
-        .def(py::init<int>())
-        .def("get", [](T &i) { return i.i + Adjust; });
-};
-
-// Simulate a foreign library base class (to match the example in the docs):
-namespace pets {
-class Pet {
-public:
-    explicit Pet(std::string name) : name_(std::move(name)) {}
-    std::string name_;
-    const std::string &name() const { return name_; }
-};
-} // namespace pets
-
-struct MixGL { int i; explicit MixGL(int i) : i{i} {} };
-struct MixGL2 { int i; explicit MixGL2(int i) : i{i} {} };

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

@@ -1,179 +0,0 @@
-#if !defined(__OBJECT_H)
-#define __OBJECT_H
-
-#include <atomic>
-#include "constructor_stats.h"
-
-/// Reference counted object base class
-class Object {
-public:
-    /// Default constructor
-    Object() { print_default_created(this); }
-
-    /// Copy constructor
-    Object(const Object &) : m_refCount(0) { print_copy_created(this); }
-
-    /// Return the current reference count
-    int getRefCount() const { return m_refCount; };
-
-    /// Increase the object's reference count by one
-    void incRef() const { ++m_refCount; }
-
-    /** \brief Decrease the reference count of
-     * the object and possibly deallocate it.
-     *
-     * The object will automatically be deallocated once
-     * the reference count reaches zero.
-     */
-    void decRef(bool dealloc = true) const {
-        --m_refCount;
-        if (m_refCount == 0 && dealloc)
-            delete this;
-        else if (m_refCount < 0)
-            throw std::runtime_error("Internal error: reference count < 0!");
-    }
-
-    virtual std::string toString() const = 0;
-protected:
-    /** \brief Virtual protected deconstructor.
-     * (Will only be called by \ref ref)
-     */
-    virtual ~Object() { print_destroyed(this); }
-private:
-    mutable std::atomic<int> m_refCount { 0 };
-};
-
-// Tag class used to track constructions of ref objects.  When we track constructors, below, we
-// track and print out the actual class (e.g. ref<MyObject>), and *also* add a fake tracker for
-// ref_tag.  This lets us check that the total number of ref<Anything> constructors/destructors is
-// correct without having to check each individual ref<Whatever> type individually.
-class ref_tag {};
-
-/**
- * \brief Reference counting helper
- *
- * The \a ref refeference template is a simple wrapper to store a
- * pointer to an object. It takes care of increasing and decreasing
- * the reference count of the object. When the last reference goes
- * out of scope, the associated object will be deallocated.
- *
- * \ingroup libcore
- */
-template <typename T> class ref {
-public:
-    /// Create a nullptr reference
-    ref() : m_ptr(nullptr) { print_default_created(this); track_default_created((ref_tag*) this); }
-
-    /// Construct a reference from a pointer
-    explicit ref(T *ptr) : m_ptr(ptr) {
-        if (m_ptr) ((Object *) m_ptr)->incRef();
-
-        print_created(this, "from pointer", m_ptr); track_created((ref_tag*) this, "from pointer");
-
-    }
-
-    /// Copy constructor
-    ref(const ref &r) : m_ptr(r.m_ptr) {
-        if (m_ptr)
-            ((Object *) m_ptr)->incRef();
-
-        print_copy_created(this, "with pointer", m_ptr); track_copy_created((ref_tag*) this);
-    }
-
-    /// Move constructor
-    ref(ref &&r) noexcept : m_ptr(r.m_ptr) {
-        r.m_ptr = nullptr;
-
-        print_move_created(this, "with pointer", m_ptr); track_move_created((ref_tag*) this);
-    }
-
-    /// Destroy this reference
-    ~ref() {
-        if (m_ptr)
-            ((Object *) m_ptr)->decRef();
-
-        print_destroyed(this); track_destroyed((ref_tag*) this);
-    }
-
-    /// Move another reference into the current one
-    ref &operator=(ref &&r) noexcept {
-        print_move_assigned(this, "pointer", r.m_ptr); track_move_assigned((ref_tag*) this);
-
-        if (*this == r)
-            return *this;
-        if (m_ptr)
-            ((Object *) m_ptr)->decRef();
-        m_ptr = r.m_ptr;
-        r.m_ptr = nullptr;
-        return *this;
-    }
-
-    /// Overwrite this reference with another reference
-    ref& operator=(const ref& r) {
-        if (this == &r) {
-            return *this;
-        }
-        print_copy_assigned(this, "pointer", r.m_ptr);
-        track_copy_assigned((ref_tag *) this);
-
-        if (m_ptr == r.m_ptr)
-            return *this;
-        if (m_ptr)
-            ((Object *) m_ptr)->decRef();
-        m_ptr = r.m_ptr;
-        if (m_ptr)
-            ((Object *) m_ptr)->incRef();
-        return *this;
-    }
-
-    /// Overwrite this reference with a pointer to another object
-    ref& operator=(T *ptr) {
-        print_values(this, "assigned pointer"); track_values((ref_tag*) this, "assigned pointer");
-
-        if (m_ptr == ptr)
-            return *this;
-        if (m_ptr)
-            ((Object *) m_ptr)->decRef();
-        m_ptr = ptr;
-        if (m_ptr)
-            ((Object *) m_ptr)->incRef();
-        return *this;
-    }
-
-    /// Compare this reference with another reference
-    bool operator==(const ref &r) const { return m_ptr == r.m_ptr; }
-
-    /// Compare this reference with another reference
-    bool operator!=(const ref &r) const { return m_ptr != r.m_ptr; }
-
-    /// Compare this reference with a pointer
-    bool operator==(const T* ptr) const { return m_ptr == ptr; }
-
-    /// Compare this reference with a pointer
-    bool operator!=(const T* ptr) const { return m_ptr != ptr; }
-
-    /// Access the object referenced by this reference
-    T* operator->() { return m_ptr; }
-
-    /// Access the object referenced by this reference
-    const T* operator->() const { return m_ptr; }
-
-    /// Return a C++ reference to the referenced object
-    T& operator*() { return *m_ptr; }
-
-    /// Return a const C++ reference to the referenced object
-    const T& operator*() const { return *m_ptr; }
-
-    /// Return a pointer to the referenced object
-    explicit operator T* () { return m_ptr; }
-
-    /// Return a const pointer to the referenced object
-    T* get_ptr() { return m_ptr; }
-
-    /// Return a pointer to the referenced object
-    const T* get_ptr() const { return m_ptr; }
-private:
-    T *m_ptr;
-};
-
-#endif /* __OBJECT_H */

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

@@ -1,151 +0,0 @@
-/*
-    tests/pybind11_cross_module_tests.cpp -- contains tests that require multiple modules
-
-    Copyright (c) 2017 Jason Rhinelander <jason@imaginary.ca>
-
-    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 "local_bindings.h"
-#include "test_exceptions.h"
-
-#include <pybind11/stl_bind.h>
-
-#include <numeric>
-#include <utility>
-
-PYBIND11_MODULE(pybind11_cross_module_tests, m) {
-    m.doc() = "pybind11 cross-module test module";
-
-    // test_local_bindings.py tests:
-    //
-    // Definitions here are tested by importing both this module and the
-    // relevant pybind11_tests submodule from a test_whatever.py
-
-    // test_load_external
-    bind_local<ExternalType1>(m, "ExternalType1", py::module_local());
-    bind_local<ExternalType2>(m, "ExternalType2", py::module_local());
-
-    // test_exceptions.py
-    py::register_local_exception<LocalSimpleException>(m, "LocalSimpleException");
-    m.def("raise_runtime_error", []() { PyErr_SetString(PyExc_RuntimeError, "My runtime error"); throw py::error_already_set(); });
-    m.def("raise_value_error", []() { PyErr_SetString(PyExc_ValueError, "My value error"); throw py::error_already_set(); });
-    m.def("throw_pybind_value_error", []() { throw py::value_error("pybind11 value error"); });
-    m.def("throw_pybind_type_error", []() { throw py::type_error("pybind11 type error"); });
-    m.def("throw_stop_iteration", []() { throw py::stop_iteration(); });
-    m.def("throw_local_error", []() { throw LocalException("just local"); });
-    m.def("throw_local_simple_error", []() { throw LocalSimpleException("external mod"); });
-    py::register_exception_translator([](std::exception_ptr p) {
-      try {
-          if (p) std::rethrow_exception(p);
-      } catch (const shared_exception &e) {
-          PyErr_SetString(PyExc_KeyError, e.what());
-      }
-    });
-
-    // translate the local exception into a key error but only in this module
-    py::register_local_exception_translator([](std::exception_ptr p) {
-      try {
-          if (p) {
-            std::rethrow_exception(p);
-          }
-      } catch (const LocalException &e) {
-        PyErr_SetString(PyExc_KeyError, e.what());
-      }
-    });
-
-    // test_local_bindings.py
-    // Local to both:
-    bind_local<LocalType, 1>(m, "LocalType", py::module_local())
-        .def("get2", [](LocalType &t) { return t.i + 2; })
-        ;
-
-    // Can only be called with our python type:
-    m.def("local_value", [](LocalType &l) { return l.i; });
-
-    // test_nonlocal_failure
-    // This registration will fail (global registration when LocalFail is already registered
-    // globally in the main test module):
-    m.def("register_nonlocal", [m]() {
-        bind_local<NonLocalType, 0>(m, "NonLocalType");
-    });
-
-    // test_stl_bind_local
-    // stl_bind.h binders defaults to py::module_local if the types are local or converting:
-    py::bind_vector<LocalVec>(m, "LocalVec");
-    py::bind_map<LocalMap>(m, "LocalMap");
-
-    // test_stl_bind_global
-    // and global if the type (or one of the types, for the map) is global (so these will fail,
-    // assuming pybind11_tests is already loaded):
-    m.def("register_nonlocal_vec", [m]() {
-        py::bind_vector<NonLocalVec>(m, "NonLocalVec");
-    });
-    m.def("register_nonlocal_map", [m]() {
-        py::bind_map<NonLocalMap>(m, "NonLocalMap");
-    });
-    // The default can, however, be overridden to global using `py::module_local()` or
-    // `py::module_local(false)`.
-    // Explicitly made local:
-    py::bind_vector<NonLocalVec2>(m, "NonLocalVec2", py::module_local());
-    // Explicitly made global (and so will fail to bind):
-    m.def("register_nonlocal_map2", [m]() {
-        py::bind_map<NonLocalMap2>(m, "NonLocalMap2", py::module_local(false));
-    });
-
-    // test_mixed_local_global
-    // We try this both with the global type registered first and vice versa (the order shouldn't
-    // matter).
-    m.def("register_mixed_global_local", [m]() {
-        bind_local<MixedGlobalLocal, 200>(m, "MixedGlobalLocal", py::module_local());
-    });
-    m.def("register_mixed_local_global", [m]() {
-        bind_local<MixedLocalGlobal, 2000>(m, "MixedLocalGlobal", py::module_local(false));
-    });
-    m.def("get_mixed_gl", [](int i) { return MixedGlobalLocal(i); });
-    m.def("get_mixed_lg", [](int i) { return MixedLocalGlobal(i); });
-
-    // test_internal_locals_differ
-    m.def("local_cpp_types_addr", []() { return (uintptr_t) &py::detail::get_local_internals().registered_types_cpp; });
-
-    // test_stl_caster_vs_stl_bind
-    py::bind_vector<std::vector<int>>(m, "VectorInt");
-
-    m.def("load_vector_via_binding", [](std::vector<int> &v) {
-        return std::accumulate(v.begin(), v.end(), 0);
-    });
-
-    // test_cross_module_calls
-    m.def("return_self", [](LocalVec *v) { return v; });
-    m.def("return_copy", [](const LocalVec &v) { return LocalVec(v); });
-
-    class Dog : public pets::Pet {
-    public:
-        explicit Dog(std::string name) : Pet(std::move(name)) {}
-    };
-    py::class_<pets::Pet>(m, "Pet", py::module_local())
-        .def("name", &pets::Pet::name);
-    // Binding for local extending class:
-    py::class_<Dog, pets::Pet>(m, "Dog")
-        .def(py::init<std::string>());
-    m.def("pet_name", [](pets::Pet &p) { return p.name(); });
-
-    py::class_<MixGL>(m, "MixGL", py::module_local()).def(py::init<int>());
-    m.def("get_gl_value", [](MixGL &o) { return o.i + 100; });
-
-    py::class_<MixGL2>(m, "MixGL2", py::module_local()).def(py::init<int>());
-
-    // test_vector_bool
-    // We can't test both stl.h and stl_bind.h conversions of `std::vector<bool>` within
-    // the same module (it would be an ODR violation). Therefore `bind_vector` of `bool`
-    // is defined here and tested in `test_stl_binders.py`.
-    py::bind_vector<std::vector<bool>>(m, "VectorBool");
-
-    // test_missing_header_message
-    // The main module already includes stl.h, but we need to test the error message
-    // which appears when this header is missing.
-    m.def("missing_header_arg", [](const std::vector<float> &) {});
-    m.def("missing_header_return", []() { return std::vector<float>(); });
-}

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

@@ -1,91 +0,0 @@
-/*
-    tests/pybind11_tests.cpp -- pybind example plugin
-
-    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 <functional>
-#include <list>
-
-/*
-For testing purposes, we define a static global variable here in a function that each individual
-test .cpp calls with its initialization lambda.  It's convenient here because we can just not
-compile some test files to disable/ignore some of the test code.
-
-It is NOT recommended as a way to use pybind11 in practice, however: the initialization order will
-be essentially random, which is okay for our test scripts (there are no dependencies between the
-individual pybind11 test .cpp files), but most likely not what you want when using pybind11
-productively.
-
-Instead, see the "How can I reduce the build time?" question in the "Frequently asked questions"
-section of the documentation for good practice on splitting binding code over multiple files.
-*/
-std::list<std::function<void(py::module_ &)>> &initializers() {
-    static std::list<std::function<void(py::module_ &)>> inits;
-    return inits;
-}
-
-test_initializer::test_initializer(Initializer init) {
-    initializers().emplace_back(init);
-}
-
-test_initializer::test_initializer(const char *submodule_name, Initializer init) {
-    initializers().emplace_back([=](py::module_ &parent) {
-        auto m = parent.def_submodule(submodule_name);
-        init(m);
-    });
-}
-
-void bind_ConstructorStats(py::module_ &m) {
-    py::class_<ConstructorStats>(m, "ConstructorStats")
-        .def("alive", &ConstructorStats::alive)
-        .def("values", &ConstructorStats::values)
-        .def_readwrite("default_constructions", &ConstructorStats::default_constructions)
-        .def_readwrite("copy_assignments", &ConstructorStats::copy_assignments)
-        .def_readwrite("move_assignments", &ConstructorStats::move_assignments)
-        .def_readwrite("copy_constructions", &ConstructorStats::copy_constructions)
-        .def_readwrite("move_constructions", &ConstructorStats::move_constructions)
-        .def_static("get", (ConstructorStats &(*)(py::object)) &ConstructorStats::get, py::return_value_policy::reference_internal)
-
-        // Not exactly ConstructorStats, but related: expose the internal pybind number of registered instances
-        // to allow instance cleanup checks (invokes a GC first)
-        .def_static("detail_reg_inst", []() {
-            ConstructorStats::gc();
-            return py::detail::get_internals().registered_instances.size();
-        })
-        ;
-}
-
-PYBIND11_MODULE(pybind11_tests, m) {
-    m.doc() = "pybind11 test module";
-
-    bind_ConstructorStats(m);
-
-#if !defined(NDEBUG)
-    m.attr("debug_enabled") = true;
-#else
-    m.attr("debug_enabled") = false;
-#endif
-
-    py::class_<UserType>(m, "UserType", "A `py::class_` type for testing")
-        .def(py::init<>())
-        .def(py::init<int>())
-        .def("get_value", &UserType::value, "Get value using a method")
-        .def("set_value", &UserType::set, "Set value using a method")
-        .def_property("value", &UserType::value, &UserType::set, "Get/set value using a property")
-        .def("__repr__", [](const UserType& u) { return "UserType({})"_s.format(u.value()); });
-
-    py::class_<IncType, UserType>(m, "IncType")
-        .def(py::init<>())
-        .def(py::init<int>())
-        .def("__repr__", [](const IncType& u) { return "IncType({})"_s.format(u.value()); });
-
-    for (const auto &initializer : initializers())
-        initializer(m);
-}