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

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

@@ -1,125 +0,0 @@
-/*
-    tests/test_iostream.cpp -- Usage of scoped_output_redirect
-
-    Copyright (c) 2017 Henry F. Schreiner
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-
-#if defined(_MSC_VER) && _MSC_VER < 1910  // VS 2015's MSVC
-#  pragma warning(disable: 4702) // unreachable code in system header (xatomic.h(382))
-#endif
-
-#include <pybind11/iostream.h>
-#include "pybind11_tests.h"
-#include <atomic>
-#include <iostream>
-#include <mutex>
-#include <string>
-#include <thread>
-
-void noisy_function(const std::string &msg, bool flush) {
-
-    std::cout << msg;
-    if (flush)
-        std::cout << std::flush;
-}
-
-void noisy_funct_dual(const std::string &msg, const std::string &emsg) {
-    std::cout << msg;
-    std::cerr << emsg;
-}
-
-// object to manage C++ thread
-// simply repeatedly write to std::cerr until stopped
-// redirect is called at some point to test the safety of scoped_estream_redirect
-struct TestThread {
-    TestThread() : stop_{false} {
-        auto thread_f = [this] {
-            static std::mutex cout_mutex;
-            while (!stop_) {
-                {
-                    // #HelpAppreciated: Work on iostream.h thread safety.
-                    // Without this lock, the clang ThreadSanitizer (tsan) reliably reports a
-                    // data race, and this test is predictably flakey on Windows.
-                    // For more background see the discussion under
-                    // https://github.com/pybind/pybind11/pull/2982 and
-                    // https://github.com/pybind/pybind11/pull/2995.
-                    const std::lock_guard<std::mutex> lock(cout_mutex);
-                    std::cout << "x" << std::flush;
-                }
-                std::this_thread::sleep_for(std::chrono::microseconds(50));
-            } };
-        t_ = new std::thread(std::move(thread_f));
-    }
-
-    ~TestThread() {
-        delete t_;
-    }
-
-    void stop() { stop_ = true; }
-
-    void join() const {
-        py::gil_scoped_release gil_lock;
-        t_->join();
-    }
-
-    void sleep() {
-        py::gil_scoped_release gil_lock;
-        std::this_thread::sleep_for(std::chrono::milliseconds(50));
-    }
-
-    std::thread *t_{nullptr};
-    std::atomic<bool> stop_;
-};
-
-
-TEST_SUBMODULE(iostream, m) {
-
-    add_ostream_redirect(m);
-
-    // test_evals
-
-    m.def("captured_output_default", [](const std::string &msg) {
-        py::scoped_ostream_redirect redir;
-        std::cout << msg << std::flush;
-    });
-
-    m.def("captured_output", [](const std::string &msg) {
-        py::scoped_ostream_redirect redir(std::cout, py::module_::import("sys").attr("stdout"));
-        std::cout << msg << std::flush;
-    });
-
-    m.def("guard_output", &noisy_function,
-            py::call_guard<py::scoped_ostream_redirect>(),
-            py::arg("msg"), py::arg("flush")=true);
-
-    m.def("captured_err", [](const std::string &msg) {
-        py::scoped_ostream_redirect redir(std::cerr, py::module_::import("sys").attr("stderr"));
-        std::cerr << msg << std::flush;
-    });
-
-    m.def("noisy_function", &noisy_function, py::arg("msg"), py::arg("flush") = true);
-
-    m.def("dual_guard", &noisy_funct_dual,
-            py::call_guard<py::scoped_ostream_redirect, py::scoped_estream_redirect>(),
-            py::arg("msg"), py::arg("emsg"));
-
-    m.def("raw_output", [](const std::string &msg) { std::cout << msg << std::flush; });
-
-    m.def("raw_err", [](const std::string &msg) { std::cerr << msg << std::flush; });
-
-    m.def("captured_dual", [](const std::string &msg, const std::string &emsg) {
-        py::scoped_ostream_redirect redirout(std::cout, py::module_::import("sys").attr("stdout"));
-        py::scoped_ostream_redirect redirerr(std::cerr, py::module_::import("sys").attr("stderr"));
-        std::cout << msg << std::flush;
-        std::cerr << emsg << std::flush;
-    });
-
-    py::class_<TestThread>(m, "TestThread")
-        .def(py::init<>())
-        .def("stop", &TestThread::stop)
-        .def("join", &TestThread::join)
-        .def("sleep", &TestThread::sleep);
-}

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

@@ -1,331 +0,0 @@
-# -*- coding: utf-8 -*-
-import sys
-from contextlib import contextmanager
-
-from pybind11_tests import iostream as m
-
-try:
-    # Python 3
-    from io import StringIO
-except ImportError:
-    # Python 2
-    try:
-        from cStringIO import StringIO
-    except ImportError:
-        from StringIO import StringIO
-
-try:
-    # Python 3.4
-    from contextlib import redirect_stdout
-except ImportError:
-
-    @contextmanager
-    def redirect_stdout(target):
-        original = sys.stdout
-        sys.stdout = target
-        yield
-        sys.stdout = original
-
-
-try:
-    # Python 3.5
-    from contextlib import redirect_stderr
-except ImportError:
-
-    @contextmanager
-    def redirect_stderr(target):
-        original = sys.stderr
-        sys.stderr = target
-        yield
-        sys.stderr = original
-
-
-def test_captured(capsys):
-    msg = "I've been redirected to Python, I hope!"
-    m.captured_output(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-
-    m.captured_output_default(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-
-    m.captured_err(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == ""
-    assert stderr == msg
-
-
-def test_captured_large_string(capsys):
-    # Make this bigger than the buffer used on the C++ side: 1024 chars
-    msg = "I've been redirected to Python, I hope!"
-    msg = msg * (1024 // len(msg) + 1)
-
-    m.captured_output_default(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-
-
-def test_captured_utf8_2byte_offset0(capsys):
-    msg = "\u07FF"
-    msg = "" + msg * (1024 // len(msg) + 1)
-
-    m.captured_output_default(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-
-
-def test_captured_utf8_2byte_offset1(capsys):
-    msg = "\u07FF"
-    msg = "1" + msg * (1024 // len(msg) + 1)
-
-    m.captured_output_default(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-
-
-def test_captured_utf8_3byte_offset0(capsys):
-    msg = "\uFFFF"
-    msg = "" + msg * (1024 // len(msg) + 1)
-
-    m.captured_output_default(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-
-
-def test_captured_utf8_3byte_offset1(capsys):
-    msg = "\uFFFF"
-    msg = "1" + msg * (1024 // len(msg) + 1)
-
-    m.captured_output_default(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-
-
-def test_captured_utf8_3byte_offset2(capsys):
-    msg = "\uFFFF"
-    msg = "12" + msg * (1024 // len(msg) + 1)
-
-    m.captured_output_default(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-
-
-def test_captured_utf8_4byte_offset0(capsys):
-    msg = "\U0010FFFF"
-    msg = "" + msg * (1024 // len(msg) + 1)
-
-    m.captured_output_default(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-
-
-def test_captured_utf8_4byte_offset1(capsys):
-    msg = "\U0010FFFF"
-    msg = "1" + msg * (1024 // len(msg) + 1)
-
-    m.captured_output_default(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-
-
-def test_captured_utf8_4byte_offset2(capsys):
-    msg = "\U0010FFFF"
-    msg = "12" + msg * (1024 // len(msg) + 1)
-
-    m.captured_output_default(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-
-
-def test_captured_utf8_4byte_offset3(capsys):
-    msg = "\U0010FFFF"
-    msg = "123" + msg * (1024 // len(msg) + 1)
-
-    m.captured_output_default(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-
-
-def test_guard_capture(capsys):
-    msg = "I've been redirected to Python, I hope!"
-    m.guard_output(msg)
-    stdout, stderr = capsys.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-
-
-def test_series_captured(capture):
-    with capture:
-        m.captured_output("a")
-        m.captured_output("b")
-    assert capture == "ab"
-
-
-def test_flush(capfd):
-    msg = "(not flushed)"
-    msg2 = "(flushed)"
-
-    with m.ostream_redirect():
-        m.noisy_function(msg, flush=False)
-        stdout, stderr = capfd.readouterr()
-        assert stdout == ""
-
-        m.noisy_function(msg2, flush=True)
-        stdout, stderr = capfd.readouterr()
-        assert stdout == msg + msg2
-
-        m.noisy_function(msg, flush=False)
-
-    stdout, stderr = capfd.readouterr()
-    assert stdout == msg
-
-
-def test_not_captured(capfd):
-    msg = "Something that should not show up in log"
-    stream = StringIO()
-    with redirect_stdout(stream):
-        m.raw_output(msg)
-    stdout, stderr = capfd.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-    assert stream.getvalue() == ""
-
-    stream = StringIO()
-    with redirect_stdout(stream):
-        m.captured_output(msg)
-    stdout, stderr = capfd.readouterr()
-    assert stdout == ""
-    assert stderr == ""
-    assert stream.getvalue() == msg
-
-
-def test_err(capfd):
-    msg = "Something that should not show up in log"
-    stream = StringIO()
-    with redirect_stderr(stream):
-        m.raw_err(msg)
-    stdout, stderr = capfd.readouterr()
-    assert stdout == ""
-    assert stderr == msg
-    assert stream.getvalue() == ""
-
-    stream = StringIO()
-    with redirect_stderr(stream):
-        m.captured_err(msg)
-    stdout, stderr = capfd.readouterr()
-    assert stdout == ""
-    assert stderr == ""
-    assert stream.getvalue() == msg
-
-
-def test_multi_captured(capfd):
-    stream = StringIO()
-    with redirect_stdout(stream):
-        m.captured_output("a")
-        m.raw_output("b")
-        m.captured_output("c")
-        m.raw_output("d")
-    stdout, stderr = capfd.readouterr()
-    assert stdout == "bd"
-    assert stream.getvalue() == "ac"
-
-
-def test_dual(capsys):
-    m.captured_dual("a", "b")
-    stdout, stderr = capsys.readouterr()
-    assert stdout == "a"
-    assert stderr == "b"
-
-
-def test_redirect(capfd):
-    msg = "Should not be in log!"
-    stream = StringIO()
-    with redirect_stdout(stream):
-        m.raw_output(msg)
-    stdout, stderr = capfd.readouterr()
-    assert stdout == msg
-    assert stream.getvalue() == ""
-
-    stream = StringIO()
-    with redirect_stdout(stream):
-        with m.ostream_redirect():
-            m.raw_output(msg)
-    stdout, stderr = capfd.readouterr()
-    assert stdout == ""
-    assert stream.getvalue() == msg
-
-    stream = StringIO()
-    with redirect_stdout(stream):
-        m.raw_output(msg)
-    stdout, stderr = capfd.readouterr()
-    assert stdout == msg
-    assert stream.getvalue() == ""
-
-
-def test_redirect_err(capfd):
-    msg = "StdOut"
-    msg2 = "StdErr"
-
-    stream = StringIO()
-    with redirect_stderr(stream):
-        with m.ostream_redirect(stdout=False):
-            m.raw_output(msg)
-            m.raw_err(msg2)
-    stdout, stderr = capfd.readouterr()
-    assert stdout == msg
-    assert stderr == ""
-    assert stream.getvalue() == msg2
-
-
-def test_redirect_both(capfd):
-    msg = "StdOut"
-    msg2 = "StdErr"
-
-    stream = StringIO()
-    stream2 = StringIO()
-    with redirect_stdout(stream):
-        with redirect_stderr(stream2):
-            with m.ostream_redirect():
-                m.raw_output(msg)
-                m.raw_err(msg2)
-    stdout, stderr = capfd.readouterr()
-    assert stdout == ""
-    assert stderr == ""
-    assert stream.getvalue() == msg
-    assert stream2.getvalue() == msg2
-
-
-def test_threading():
-    with m.ostream_redirect(stdout=True, stderr=False):
-        # start some threads
-        threads = []
-
-        # start some threads
-        for _j in range(20):
-            threads.append(m.TestThread())
-
-        # give the threads some time to fail
-        threads[0].sleep()
-
-        # stop all the threads
-        for t in threads:
-            t.stop()
-
-        for t in threads:
-            t.join()
-
-        # if a thread segfaults, we don't get here
-        assert True

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

@@ -1,153 +0,0 @@
-/*
-    tests/test_kwargs_and_defaults.cpp -- keyword arguments and default values
-
-    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>
-
-#include <utility>
-
-TEST_SUBMODULE(kwargs_and_defaults, m) {
-    auto kw_func = [](int x, int y) { return "x=" + std::to_string(x) + ", y=" + std::to_string(y); };
-
-    // test_named_arguments
-    m.def("kw_func0", kw_func);
-    m.def("kw_func1", kw_func, py::arg("x"), py::arg("y"));
-    m.def("kw_func2", kw_func, py::arg("x") = 100, py::arg("y") = 200);
-    m.def("kw_func3", [](const char *) { }, py::arg("data") = std::string("Hello world!"));
-
-    /* A fancier default argument */
-    std::vector<int> list{{13, 17}};
-    m.def("kw_func4", [](const std::vector<int> &entries) {
-        std::string ret = "{";
-        for (int i : entries)
-            ret += std::to_string(i) + " ";
-        ret.back() = '}';
-        return ret;
-    }, py::arg("myList") = list);
-
-    m.def("kw_func_udl", kw_func, "x"_a, "y"_a=300);
-    m.def("kw_func_udl_z", kw_func, "x"_a, "y"_a=0);
-
-    // test_args_and_kwargs
-    m.def("args_function", [](py::args args) -> py::tuple {
-        return std::move(args);
-    });
-    m.def("args_kwargs_function", [](const py::args &args, const py::kwargs &kwargs) {
-        return py::make_tuple(args, kwargs);
-    });
-
-    // test_mixed_args_and_kwargs
-    m.def("mixed_plus_args",
-          [](int i, double j, const py::args &args) { return py::make_tuple(i, j, args); });
-    m.def("mixed_plus_kwargs",
-          [](int i, double j, const py::kwargs &kwargs) { return py::make_tuple(i, j, kwargs); });
-    auto mixed_plus_both = [](int i, double j, const py::args &args, const py::kwargs &kwargs) {
-        return py::make_tuple(i, j, args, kwargs);
-    };
-    m.def("mixed_plus_args_kwargs", mixed_plus_both);
-
-    m.def("mixed_plus_args_kwargs_defaults", mixed_plus_both,
-            py::arg("i") = 1, py::arg("j") = 3.14159);
-
-    // test_args_refcount
-    // PyPy needs a garbage collection to get the reference count values to match CPython's behaviour
-    #ifdef PYPY_VERSION
-    #define GC_IF_NEEDED ConstructorStats::gc()
-    #else
-    #define GC_IF_NEEDED
-    #endif
-    m.def("arg_refcount_h", [](py::handle h) { GC_IF_NEEDED; return h.ref_count(); });
-    m.def("arg_refcount_h", [](py::handle h, py::handle, py::handle) { GC_IF_NEEDED; return h.ref_count(); });
-    m.def("arg_refcount_o", [](const py::object &o) {
-        GC_IF_NEEDED;
-        return o.ref_count();
-    });
-    m.def("args_refcount", [](py::args a) {
-        GC_IF_NEEDED;
-        py::tuple t(a.size());
-        for (size_t i = 0; i < a.size(); i++)
-            // Use raw Python API here to avoid an extra, intermediate incref on the tuple item:
-            t[i] = (int) Py_REFCNT(PyTuple_GET_ITEM(a.ptr(), static_cast<py::ssize_t>(i)));
-        return t;
-    });
-    m.def("mixed_args_refcount", [](const py::object &o, py::args a) {
-        GC_IF_NEEDED;
-        py::tuple t(a.size() + 1);
-        t[0] = o.ref_count();
-        for (size_t i = 0; i < a.size(); i++)
-            // Use raw Python API here to avoid an extra, intermediate incref on the tuple item:
-            t[i + 1] = (int) Py_REFCNT(PyTuple_GET_ITEM(a.ptr(), static_cast<py::ssize_t>(i)));
-        return t;
-    });
-
-    // pybind11 won't allow these to be bound: args and kwargs, if present, must be at the end.
-    // Uncomment these to test that the static_assert is indeed working:
-//    m.def("bad_args1", [](py::args, int) {});
-//    m.def("bad_args2", [](py::kwargs, int) {});
-//    m.def("bad_args3", [](py::kwargs, py::args) {});
-//    m.def("bad_args4", [](py::args, int, py::kwargs) {});
-//    m.def("bad_args5", [](py::args, py::kwargs, int) {});
-//    m.def("bad_args6", [](py::args, py::args) {});
-//    m.def("bad_args7", [](py::kwargs, py::kwargs) {});
-
-    // test_keyword_only_args
-    m.def("kw_only_all", [](int i, int j) { return py::make_tuple(i, j); },
-            py::kw_only(), py::arg("i"), py::arg("j"));
-    m.def("kw_only_some", [](int i, int j, int k) { return py::make_tuple(i, j, k); },
-            py::arg(), py::kw_only(), py::arg("j"), py::arg("k"));
-    m.def("kw_only_with_defaults", [](int i, int j, int k, int z) { return py::make_tuple(i, j, k, z); },
-            py::arg() = 3, "j"_a = 4, py::kw_only(), "k"_a = 5, "z"_a);
-    m.def("kw_only_mixed", [](int i, int j) { return py::make_tuple(i, j); },
-            "i"_a, py::kw_only(), "j"_a);
-    m.def(
-        "kw_only_plus_more",
-        [](int i, int j, int k, const py::kwargs &kwargs) {
-            return py::make_tuple(i, j, k, kwargs);
-        },
-        py::arg() /* positional */,
-        py::arg("j") = -1 /* both */,
-        py::kw_only(),
-        py::arg("k") /* kw-only */);
-
-    m.def("register_invalid_kw_only", [](py::module_ m) {
-        m.def("bad_kw_only", [](int i, int j) { return py::make_tuple(i, j); },
-                py::kw_only(), py::arg() /* invalid unnamed argument */, "j"_a);
-    });
-
-    // test_positional_only_args
-    m.def("pos_only_all", [](int i, int j) { return py::make_tuple(i, j); },
-            py::arg("i"), py::arg("j"), py::pos_only());
-    m.def("pos_only_mix", [](int i, int j) { return py::make_tuple(i, j); },
-            py::arg("i"), py::pos_only(), py::arg("j"));
-    m.def("pos_kw_only_mix", [](int i, int j, int k) { return py::make_tuple(i, j, k); },
-            py::arg("i"), py::pos_only(), py::arg("j"), py::kw_only(), py::arg("k"));
-    m.def("pos_only_def_mix", [](int i, int j, int k) { return py::make_tuple(i, j, k); },
-            py::arg("i"), py::arg("j") = 2, py::pos_only(), py::arg("k") = 3);
-
-
-    // These should fail to compile:
-    // argument annotations are required when using kw_only
-//    m.def("bad_kw_only1", [](int) {}, py::kw_only());
-    // can't specify both `py::kw_only` and a `py::args` argument
-//    m.def("bad_kw_only2", [](int i, py::args) {}, py::kw_only(), "i"_a);
-
-    // test_function_signatures (along with most of the above)
-    struct KWClass { void foo(int, float) {} };
-    py::class_<KWClass>(m, "KWClass")
-        .def("foo0", &KWClass::foo)
-        .def("foo1", &KWClass::foo, "x"_a, "y"_a);
-
-    // Make sure a class (not an instance) can be used as a default argument.
-    // The return value doesn't matter, only that the module is importable.
-    m.def(
-        "class_default_argument",
-        [](py::object a) { return py::repr(std::move(a)); },
-        "a"_a = py::module_::import("decimal").attr("Decimal"));
-}