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

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

@@ -1,285 +0,0 @@
-/*
-    tests/test_custom-exceptions.cpp -- exception translation
-
-    Copyright (c) 2016 Pim Schellart <P.Schellart@princeton.edu>
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-*/
-#include "test_exceptions.h"
-
-#include "local_bindings.h"
-
-#include "pybind11_tests.h"
-#include <utility>
-
-// A type that should be raised as an exception in Python
-class MyException : public std::exception {
-public:
-    explicit MyException(const char * m) : message{m} {}
-    const char * what() const noexcept override {return message.c_str();}
-private:
-    std::string message = "";
-};
-
-// A type that should be translated to a standard Python exception
-class MyException2 : public std::exception {
-public:
-    explicit MyException2(const char * m) : message{m} {}
-    const char * what() const noexcept override {return message.c_str();}
-private:
-    std::string message = "";
-};
-
-// A type that is not derived from std::exception (and is thus unknown)
-class MyException3 {
-public:
-    explicit MyException3(const char * m) : message{m} {}
-    virtual const char * what() const noexcept {return message.c_str();}
-    // Rule of 5 BEGIN: to preempt compiler warnings.
-    MyException3(const MyException3&) = default;
-    MyException3(MyException3&&) = default;
-    MyException3& operator=(const MyException3&) = default;
-    MyException3& operator=(MyException3&&) = default;
-    virtual ~MyException3() = default;
-    // Rule of 5 END.
-private:
-    std::string message = "";
-};
-
-// A type that should be translated to MyException
-// and delegated to its exception translator
-class MyException4 : public std::exception {
-public:
-    explicit MyException4(const char * m) : message{m} {}
-    const char * what() const noexcept override {return message.c_str();}
-private:
-    std::string message = "";
-};
-
-
-// Like the above, but declared via the helper function
-class MyException5 : public std::logic_error {
-public:
-    explicit MyException5(const std::string &what) : std::logic_error(what) {}
-};
-
-// Inherits from MyException5
-class MyException5_1 : public MyException5 {
-    using MyException5::MyException5;
-};
-
-
-// Exception that will be caught via the module local translator.
-class MyException6 : public std::exception {
-public:
-    explicit MyException6(const char * m) : message{m} {}
-    const char * what() const noexcept override {return message.c_str();}
-private:
-    std::string message = "";
-};
-
-
-struct PythonCallInDestructor {
-    explicit PythonCallInDestructor(const py::dict &d) : d(d) {}
-    ~PythonCallInDestructor() { d["good"] = true; }
-
-    py::dict d;
-};
-
-
-
-struct PythonAlreadySetInDestructor {
-    explicit PythonAlreadySetInDestructor(const py::str &s) : s(s) {}
-    ~PythonAlreadySetInDestructor() {
-        py::dict foo;
-        try {
-            // Assign to a py::object to force read access of nonexistent dict entry
-            py::object o = foo["bar"];
-        }
-        catch (py::error_already_set& ex) {
-            ex.discard_as_unraisable(s);
-        }
-    }
-
-    py::str s;
-};
-
-
-TEST_SUBMODULE(exceptions, m) {
-    m.def("throw_std_exception", []() {
-        throw std::runtime_error("This exception was intentionally thrown.");
-    });
-
-    // make a new custom exception and use it as a translation target
-    static py::exception<MyException> ex(m, "MyException");
-    py::register_exception_translator([](std::exception_ptr p) {
-        try {
-            if (p) std::rethrow_exception(p);
-        } catch (const MyException &e) {
-            // Set MyException as the active python error
-            ex(e.what());
-        }
-    });
-
-    // register new translator for MyException2
-    // no need to store anything here because this type will
-    // never by visible from Python
-    py::register_exception_translator([](std::exception_ptr p) {
-        try {
-            if (p) std::rethrow_exception(p);
-        } catch (const MyException2 &e) {
-            // Translate this exception to a standard RuntimeError
-            PyErr_SetString(PyExc_RuntimeError, e.what());
-        }
-    });
-
-    // register new translator for MyException4
-    // which will catch it and delegate to the previously registered
-    // translator for MyException by throwing a new exception
-    py::register_exception_translator([](std::exception_ptr p) {
-        try {
-            if (p) std::rethrow_exception(p);
-        } catch (const MyException4 &e) {
-            throw MyException(e.what());
-        }
-    });
-
-    // A simple exception translation:
-    auto ex5 = py::register_exception<MyException5>(m, "MyException5");
-    // A slightly more complicated one that declares MyException5_1 as a subclass of MyException5
-    py::register_exception<MyException5_1>(m, "MyException5_1", ex5.ptr());
-
-    //py::register_local_exception<LocalSimpleException>(m, "LocalSimpleException")
-
-    py::register_local_exception_translator([](std::exception_ptr p) {
-      try {
-          if (p) {
-            std::rethrow_exception(p);
-          }
-      } catch (const MyException6 &e) {
-        PyErr_SetString(PyExc_RuntimeError, e.what());
-      }
-    });
-
-    m.def("throws1", []() { throw MyException("this error should go to a custom type"); });
-    m.def("throws2", []() { throw MyException2("this error should go to a standard Python exception"); });
-    m.def("throws3", []() { throw MyException3("this error cannot be translated"); });
-    m.def("throws4", []() { throw MyException4("this error is rethrown"); });
-    m.def("throws5", []() { throw MyException5("this is a helper-defined translated exception"); });
-    m.def("throws5_1", []() { throw MyException5_1("MyException5 subclass"); });
-    m.def("throws6", []() { throw MyException6("MyException6 only handled in this module"); });
-    m.def("throws_logic_error", []() { throw std::logic_error("this error should fall through to the standard handler"); });
-    m.def("throws_overflow_error", []() { throw std::overflow_error(""); });
-    m.def("throws_local_error", []() { throw LocalException("never caught"); });
-    m.def("throws_local_simple_error", []() { throw LocalSimpleException("this mod"); });
-    m.def("exception_matches", []() {
-        py::dict foo;
-        try {
-            // Assign to a py::object to force read access of nonexistent dict entry
-            py::object o = foo["bar"];
-        }
-        catch (py::error_already_set& ex) {
-            if (!ex.matches(PyExc_KeyError)) throw;
-            return true;
-        }
-        return false;
-    });
-    m.def("exception_matches_base", []() {
-        py::dict foo;
-        try {
-            // Assign to a py::object to force read access of nonexistent dict entry
-            py::object o = foo["bar"];
-        }
-        catch (py::error_already_set &ex) {
-            if (!ex.matches(PyExc_Exception)) throw;
-            return true;
-        }
-        return false;
-    });
-    m.def("modulenotfound_exception_matches_base", []() {
-        try {
-            // On Python >= 3.6, this raises a ModuleNotFoundError, a subclass of ImportError
-            py::module_::import("nonexistent");
-        }
-        catch (py::error_already_set &ex) {
-            if (!ex.matches(PyExc_ImportError)) throw;
-            return true;
-        }
-        return false;
-    });
-
-    m.def("throw_already_set", [](bool err) {
-        if (err)
-            PyErr_SetString(PyExc_ValueError, "foo");
-        try {
-            throw py::error_already_set();
-        } catch (const std::runtime_error& e) {
-            if ((err && e.what() != std::string("ValueError: foo")) ||
-                (!err && e.what() != std::string("Unknown internal error occurred")))
-            {
-                PyErr_Clear();
-                throw std::runtime_error("error message mismatch");
-            }
-        }
-        PyErr_Clear();
-        if (err)
-            PyErr_SetString(PyExc_ValueError, "foo");
-        throw py::error_already_set();
-    });
-
-    m.def("python_call_in_destructor", [](const py::dict &d) {
-        bool retval = false;
-        try {
-            PythonCallInDestructor set_dict_in_destructor(d);
-            PyErr_SetString(PyExc_ValueError, "foo");
-            throw py::error_already_set();
-        } catch (const py::error_already_set&) {
-            retval = true;
-        }
-        return retval;
-    });
-
-    m.def("python_alreadyset_in_destructor", [](const py::str &s) {
-        PythonAlreadySetInDestructor alreadyset_in_destructor(s);
-        return true;
-    });
-
-    // test_nested_throws
-    m.def("try_catch",
-          [m](const py::object &exc_type, const py::function &f, const py::args &args) {
-              try {
-                  f(*args);
-              } catch (py::error_already_set &ex) {
-                  if (ex.matches(exc_type))
-                      py::print(ex.what());
-                  else
-                      throw;
-              }
-          });
-
-    // Test repr that cannot be displayed
-    m.def("simple_bool_passthrough", [](bool x) {return x;});
-
-    m.def("throw_should_be_translated_to_key_error", []() { throw shared_exception(); });
-
-#if PY_VERSION_HEX >= 0x03030000
-
-    m.def("raise_from", []() {
-        PyErr_SetString(PyExc_ValueError, "inner");
-        py::raise_from(PyExc_ValueError, "outer");
-        throw py::error_already_set();
-    });
-
-    m.def("raise_from_already_set", []() {
-        try {
-            PyErr_SetString(PyExc_ValueError, "inner");
-            throw py::error_already_set();
-        } catch (py::error_already_set& e) {
-            py::raise_from(e, PyExc_ValueError, "outer");
-            throw py::error_already_set();
-        }
-    });
-
-#endif
-}

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

@@ -1,12 +0,0 @@
-#pragma once
-#include "pybind11_tests.h"
-#include <stdexcept>
-
-// shared exceptions for cross_module_tests
-
-class PYBIND11_EXPORT_EXCEPTION shared_exception : public pybind11::builtin_exception {
-public:
-    using builtin_exception::builtin_exception;
-    explicit shared_exception() : shared_exception("") {}
-    void set_error() const override { PyErr_SetString(PyExc_RuntimeError, what()); }
-};

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

@@ -1,265 +0,0 @@
-# -*- coding: utf-8 -*-
-import sys
-
-import pytest
-
-import env  # noqa: F401
-import pybind11_cross_module_tests as cm
-from pybind11_tests import exceptions as m
-
-
-def test_std_exception(msg):
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throw_std_exception()
-    assert msg(excinfo.value) == "This exception was intentionally thrown."
-
-
-def test_error_already_set(msg):
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throw_already_set(False)
-    assert msg(excinfo.value) == "Unknown internal error occurred"
-
-    with pytest.raises(ValueError) as excinfo:
-        m.throw_already_set(True)
-    assert msg(excinfo.value) == "foo"
-
-
-@pytest.mark.skipif("env.PY2")
-def test_raise_from(msg):
-    with pytest.raises(ValueError) as excinfo:
-        m.raise_from()
-    assert msg(excinfo.value) == "outer"
-    assert msg(excinfo.value.__cause__) == "inner"
-
-
-@pytest.mark.skipif("env.PY2")
-def test_raise_from_already_set(msg):
-    with pytest.raises(ValueError) as excinfo:
-        m.raise_from_already_set()
-    assert msg(excinfo.value) == "outer"
-    assert msg(excinfo.value.__cause__) == "inner"
-
-
-def test_cross_module_exceptions(msg):
-    with pytest.raises(RuntimeError) as excinfo:
-        cm.raise_runtime_error()
-    assert str(excinfo.value) == "My runtime error"
-
-    with pytest.raises(ValueError) as excinfo:
-        cm.raise_value_error()
-    assert str(excinfo.value) == "My value error"
-
-    with pytest.raises(ValueError) as excinfo:
-        cm.throw_pybind_value_error()
-    assert str(excinfo.value) == "pybind11 value error"
-
-    with pytest.raises(TypeError) as excinfo:
-        cm.throw_pybind_type_error()
-    assert str(excinfo.value) == "pybind11 type error"
-
-    with pytest.raises(StopIteration) as excinfo:
-        cm.throw_stop_iteration()
-
-    with pytest.raises(cm.LocalSimpleException) as excinfo:
-        cm.throw_local_simple_error()
-    assert msg(excinfo.value) == "external mod"
-
-    with pytest.raises(KeyError) as excinfo:
-        cm.throw_local_error()
-    # KeyError is a repr of the key, so it has an extra set of quotes
-    assert str(excinfo.value) == "'just local'"
-
-
-# TODO: FIXME
-@pytest.mark.xfail(
-    "env.PYPY and env.MACOS",
-    raises=RuntimeError,
-    reason="Expected failure with PyPy and libc++ (Issue #2847 & PR #2999)",
-)
-def test_cross_module_exception_translator():
-    with pytest.raises(KeyError):
-        # translator registered in cross_module_tests
-        m.throw_should_be_translated_to_key_error()
-
-
-def test_python_call_in_catch():
-    d = {}
-    assert m.python_call_in_destructor(d) is True
-    assert d["good"] is True
-
-
-def ignore_pytest_unraisable_warning(f):
-    unraisable = "PytestUnraisableExceptionWarning"
-    if hasattr(pytest, unraisable):  # Python >= 3.8 and pytest >= 6
-        dec = pytest.mark.filterwarnings("ignore::pytest.{}".format(unraisable))
-        return dec(f)
-    else:
-        return f
-
-
-@ignore_pytest_unraisable_warning
-def test_python_alreadyset_in_destructor(monkeypatch, capsys):
-    hooked = False
-    triggered = [False]  # mutable, so Python 2.7 closure can modify it
-
-    if hasattr(sys, "unraisablehook"):  # Python 3.8+
-        hooked = True
-        # Don't take `sys.unraisablehook`, as that's overwritten by pytest
-        default_hook = sys.__unraisablehook__
-
-        def hook(unraisable_hook_args):
-            exc_type, exc_value, exc_tb, err_msg, obj = unraisable_hook_args
-            if obj == "already_set demo":
-                triggered[0] = True
-            default_hook(unraisable_hook_args)
-            return
-
-        # Use monkeypatch so pytest can apply and remove the patch as appropriate
-        monkeypatch.setattr(sys, "unraisablehook", hook)
-
-    assert m.python_alreadyset_in_destructor("already_set demo") is True
-    if hooked:
-        assert triggered[0] is True
-
-    _, captured_stderr = capsys.readouterr()
-    # Error message is different in Python 2 and 3, check for words that appear in both
-    assert "ignored" in captured_stderr and "already_set demo" in captured_stderr
-
-
-def test_exception_matches():
-    assert m.exception_matches()
-    assert m.exception_matches_base()
-    assert m.modulenotfound_exception_matches_base()
-
-
-def test_custom(msg):
-    # Can we catch a MyException?
-    with pytest.raises(m.MyException) as excinfo:
-        m.throws1()
-    assert msg(excinfo.value) == "this error should go to a custom type"
-
-    # Can we translate to standard Python exceptions?
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throws2()
-    assert msg(excinfo.value) == "this error should go to a standard Python exception"
-
-    # Can we handle unknown exceptions?
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throws3()
-    assert msg(excinfo.value) == "Caught an unknown exception!"
-
-    # Can we delegate to another handler by rethrowing?
-    with pytest.raises(m.MyException) as excinfo:
-        m.throws4()
-    assert msg(excinfo.value) == "this error is rethrown"
-
-    # Can we fall-through to the default handler?
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throws_logic_error()
-    assert (
-        msg(excinfo.value) == "this error should fall through to the standard handler"
-    )
-
-    # OverFlow error translation.
-    with pytest.raises(OverflowError) as excinfo:
-        m.throws_overflow_error()
-
-    # Can we handle a helper-declared exception?
-    with pytest.raises(m.MyException5) as excinfo:
-        m.throws5()
-    assert msg(excinfo.value) == "this is a helper-defined translated exception"
-
-    # Exception subclassing:
-    with pytest.raises(m.MyException5) as excinfo:
-        m.throws5_1()
-    assert msg(excinfo.value) == "MyException5 subclass"
-    assert isinstance(excinfo.value, m.MyException5_1)
-
-    with pytest.raises(m.MyException5_1) as excinfo:
-        m.throws5_1()
-    assert msg(excinfo.value) == "MyException5 subclass"
-
-    with pytest.raises(m.MyException5) as excinfo:
-        try:
-            m.throws5()
-        except m.MyException5_1:
-            raise RuntimeError("Exception error: caught child from parent")
-    assert msg(excinfo.value) == "this is a helper-defined translated exception"
-
-
-def test_nested_throws(capture):
-    """Tests nested (e.g. C++ -> Python -> C++) exception handling"""
-
-    def throw_myex():
-        raise m.MyException("nested error")
-
-    def throw_myex5():
-        raise m.MyException5("nested error 5")
-
-    # In the comments below, the exception is caught in the first step, thrown in the last step
-
-    # C++ -> Python
-    with capture:
-        m.try_catch(m.MyException5, throw_myex5)
-    assert str(capture).startswith("MyException5: nested error 5")
-
-    # Python -> C++ -> Python
-    with pytest.raises(m.MyException) as excinfo:
-        m.try_catch(m.MyException5, throw_myex)
-    assert str(excinfo.value) == "nested error"
-
-    def pycatch(exctype, f, *args):
-        try:
-            f(*args)
-        except m.MyException as e:
-            print(e)
-
-    # C++ -> Python -> C++ -> Python
-    with capture:
-        m.try_catch(
-            m.MyException5,
-            pycatch,
-            m.MyException,
-            m.try_catch,
-            m.MyException,
-            throw_myex5,
-        )
-    assert str(capture).startswith("MyException5: nested error 5")
-
-    # C++ -> Python -> C++
-    with capture:
-        m.try_catch(m.MyException, pycatch, m.MyException5, m.throws4)
-    assert capture == "this error is rethrown"
-
-    # Python -> C++ -> Python -> C++
-    with pytest.raises(m.MyException5) as excinfo:
-        m.try_catch(m.MyException, pycatch, m.MyException, m.throws5)
-    assert str(excinfo.value) == "this is a helper-defined translated exception"
-
-
-# This can often happen if you wrap a pybind11 class in a Python wrapper
-def test_invalid_repr():
-    class MyRepr(object):
-        def __repr__(self):
-            raise AttributeError("Example error")
-
-    with pytest.raises(TypeError):
-        m.simple_bool_passthrough(MyRepr())
-
-
-def test_local_translator(msg):
-    """Tests that a local translator works and that the local translator from
-    the cross module is not applied"""
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throws6()
-    assert msg(excinfo.value) == "MyException6 only handled in this module"
-
-    with pytest.raises(RuntimeError) as excinfo:
-        m.throws_local_error()
-    assert not isinstance(excinfo.value, KeyError)
-    assert msg(excinfo.value) == "never caught"
-
-    with pytest.raises(Exception) as excinfo:
-        m.throws_local_simple_error()
-    assert not isinstance(excinfo.value, cm.LocalSimpleException)
-    assert msg(excinfo.value) == "this mod"