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

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

@@ -1,272 +0,0 @@
-# -*- coding: utf-8 -*-
-import pytest
-
-import env
-from pybind11_tests import enums as m
-
-
-def test_unscoped_enum():
-    assert str(m.UnscopedEnum.EOne) == "UnscopedEnum.EOne"
-    assert str(m.UnscopedEnum.ETwo) == "UnscopedEnum.ETwo"
-    assert str(m.EOne) == "UnscopedEnum.EOne"
-    assert repr(m.UnscopedEnum.EOne) == "<UnscopedEnum.EOne: 1>"
-    assert repr(m.UnscopedEnum.ETwo) == "<UnscopedEnum.ETwo: 2>"
-    assert repr(m.EOne) == "<UnscopedEnum.EOne: 1>"
-
-    # name property
-    assert m.UnscopedEnum.EOne.name == "EOne"
-    assert m.UnscopedEnum.EOne.value == 1
-    assert m.UnscopedEnum.ETwo.name == "ETwo"
-    assert m.UnscopedEnum.ETwo.value == 2
-    assert m.EOne is m.UnscopedEnum.EOne
-    # name, value readonly
-    with pytest.raises(AttributeError):
-        m.UnscopedEnum.EOne.name = ""
-    with pytest.raises(AttributeError):
-        m.UnscopedEnum.EOne.value = 10
-    # name, value returns a copy
-    # TODO: Neither the name nor value tests actually check against aliasing.
-    # Use a mutable type that has reference semantics.
-    nonaliased_name = m.UnscopedEnum.EOne.name
-    nonaliased_name = "bar"  # noqa: F841
-    assert m.UnscopedEnum.EOne.name == "EOne"
-    nonaliased_value = m.UnscopedEnum.EOne.value
-    nonaliased_value = 10  # noqa: F841
-    assert m.UnscopedEnum.EOne.value == 1
-
-    # __members__ property
-    assert m.UnscopedEnum.__members__ == {
-        "EOne": m.UnscopedEnum.EOne,
-        "ETwo": m.UnscopedEnum.ETwo,
-        "EThree": m.UnscopedEnum.EThree,
-    }
-    # __members__ readonly
-    with pytest.raises(AttributeError):
-        m.UnscopedEnum.__members__ = {}
-    # __members__ returns a copy
-    nonaliased_members = m.UnscopedEnum.__members__
-    nonaliased_members["bar"] = "baz"
-    assert m.UnscopedEnum.__members__ == {
-        "EOne": m.UnscopedEnum.EOne,
-        "ETwo": m.UnscopedEnum.ETwo,
-        "EThree": m.UnscopedEnum.EThree,
-    }
-
-    for docstring_line in """An unscoped enumeration
-
-Members:
-
-  EOne : Docstring for EOne
-
-  ETwo : Docstring for ETwo
-
-  EThree : Docstring for EThree""".split(
-        "\n"
-    ):
-        assert docstring_line in m.UnscopedEnum.__doc__
-
-    # Unscoped enums will accept ==/!= int comparisons
-    y = m.UnscopedEnum.ETwo
-    assert y == 2
-    assert 2 == y
-    assert y != 3
-    assert 3 != y
-    # Compare with None
-    assert y != None  # noqa: E711
-    assert not (y == None)  # noqa: E711
-    # Compare with an object
-    assert y != object()
-    assert not (y == object())
-    # Compare with string
-    assert y != "2"
-    assert "2" != y
-    assert not ("2" == y)
-    assert not (y == "2")
-
-    with pytest.raises(TypeError):
-        y < object()  # noqa: B015
-
-    with pytest.raises(TypeError):
-        y <= object()  # noqa: B015
-
-    with pytest.raises(TypeError):
-        y > object()  # noqa: B015
-
-    with pytest.raises(TypeError):
-        y >= object()  # noqa: B015
-
-    with pytest.raises(TypeError):
-        y | object()
-
-    with pytest.raises(TypeError):
-        y & object()
-
-    with pytest.raises(TypeError):
-        y ^ object()
-
-    assert int(m.UnscopedEnum.ETwo) == 2
-    assert str(m.UnscopedEnum(2)) == "UnscopedEnum.ETwo"
-
-    # order
-    assert m.UnscopedEnum.EOne < m.UnscopedEnum.ETwo
-    assert m.UnscopedEnum.EOne < 2
-    assert m.UnscopedEnum.ETwo > m.UnscopedEnum.EOne
-    assert m.UnscopedEnum.ETwo > 1
-    assert m.UnscopedEnum.ETwo <= 2
-    assert m.UnscopedEnum.ETwo >= 2
-    assert m.UnscopedEnum.EOne <= m.UnscopedEnum.ETwo
-    assert m.UnscopedEnum.EOne <= 2
-    assert m.UnscopedEnum.ETwo >= m.UnscopedEnum.EOne
-    assert m.UnscopedEnum.ETwo >= 1
-    assert not (m.UnscopedEnum.ETwo < m.UnscopedEnum.EOne)
-    assert not (2 < m.UnscopedEnum.EOne)
-
-    # arithmetic
-    assert m.UnscopedEnum.EOne & m.UnscopedEnum.EThree == m.UnscopedEnum.EOne
-    assert m.UnscopedEnum.EOne | m.UnscopedEnum.ETwo == m.UnscopedEnum.EThree
-    assert m.UnscopedEnum.EOne ^ m.UnscopedEnum.EThree == m.UnscopedEnum.ETwo
-
-
-def test_scoped_enum():
-    assert m.test_scoped_enum(m.ScopedEnum.Three) == "ScopedEnum::Three"
-    z = m.ScopedEnum.Two
-    assert m.test_scoped_enum(z) == "ScopedEnum::Two"
-
-    # Scoped enums will *NOT* accept ==/!= int comparisons (Will always return False)
-    assert not z == 3
-    assert not 3 == z
-    assert z != 3
-    assert 3 != z
-    # Compare with None
-    assert z != None  # noqa: E711
-    assert not (z == None)  # noqa: E711
-    # Compare with an object
-    assert z != object()
-    assert not (z == object())
-    # Scoped enums will *NOT* accept >, <, >= and <= int comparisons (Will throw exceptions)
-    with pytest.raises(TypeError):
-        z > 3  # noqa: B015
-    with pytest.raises(TypeError):
-        z < 3  # noqa: B015
-    with pytest.raises(TypeError):
-        z >= 3  # noqa: B015
-    with pytest.raises(TypeError):
-        z <= 3  # noqa: B015
-
-    # order
-    assert m.ScopedEnum.Two < m.ScopedEnum.Three
-    assert m.ScopedEnum.Three > m.ScopedEnum.Two
-    assert m.ScopedEnum.Two <= m.ScopedEnum.Three
-    assert m.ScopedEnum.Two <= m.ScopedEnum.Two
-    assert m.ScopedEnum.Two >= m.ScopedEnum.Two
-    assert m.ScopedEnum.Three >= m.ScopedEnum.Two
-
-
-def test_implicit_conversion():
-    assert str(m.ClassWithUnscopedEnum.EMode.EFirstMode) == "EMode.EFirstMode"
-    assert str(m.ClassWithUnscopedEnum.EFirstMode) == "EMode.EFirstMode"
-    assert repr(m.ClassWithUnscopedEnum.EMode.EFirstMode) == "<EMode.EFirstMode: 1>"
-    assert repr(m.ClassWithUnscopedEnum.EFirstMode) == "<EMode.EFirstMode: 1>"
-
-    f = m.ClassWithUnscopedEnum.test_function
-    first = m.ClassWithUnscopedEnum.EFirstMode
-    second = m.ClassWithUnscopedEnum.ESecondMode
-
-    assert f(first) == 1
-
-    assert f(first) == f(first)
-    assert not f(first) != f(first)
-
-    assert f(first) != f(second)
-    assert not f(first) == f(second)
-
-    assert f(first) == int(f(first))
-    assert not f(first) != int(f(first))
-
-    assert f(first) != int(f(second))
-    assert not f(first) == int(f(second))
-
-    # noinspection PyDictCreation
-    x = {f(first): 1, f(second): 2}
-    x[f(first)] = 3
-    x[f(second)] = 4
-    # Hashing test
-    assert repr(x) == "{<EMode.EFirstMode: 1>: 3, <EMode.ESecondMode: 2>: 4}"
-
-
-def test_binary_operators():
-    assert int(m.Flags.Read) == 4
-    assert int(m.Flags.Write) == 2
-    assert int(m.Flags.Execute) == 1
-    assert int(m.Flags.Read | m.Flags.Write | m.Flags.Execute) == 7
-    assert int(m.Flags.Read | m.Flags.Write) == 6
-    assert int(m.Flags.Read | m.Flags.Execute) == 5
-    assert int(m.Flags.Write | m.Flags.Execute) == 3
-    assert int(m.Flags.Write | 1) == 3
-    assert ~m.Flags.Write == -3
-
-    state = m.Flags.Read | m.Flags.Write
-    assert (state & m.Flags.Read) != 0
-    assert (state & m.Flags.Write) != 0
-    assert (state & m.Flags.Execute) == 0
-    assert (state & 1) == 0
-
-    state2 = ~state
-    assert state2 == -7
-    assert int(state ^ state2) == -1
-
-
-def test_enum_to_int():
-    m.test_enum_to_int(m.Flags.Read)
-    m.test_enum_to_int(m.ClassWithUnscopedEnum.EMode.EFirstMode)
-    m.test_enum_to_int(m.ScopedCharEnum.Positive)
-    m.test_enum_to_int(m.ScopedBoolEnum.TRUE)
-    m.test_enum_to_uint(m.Flags.Read)
-    m.test_enum_to_uint(m.ClassWithUnscopedEnum.EMode.EFirstMode)
-    m.test_enum_to_uint(m.ScopedCharEnum.Positive)
-    m.test_enum_to_uint(m.ScopedBoolEnum.TRUE)
-    m.test_enum_to_long_long(m.Flags.Read)
-    m.test_enum_to_long_long(m.ClassWithUnscopedEnum.EMode.EFirstMode)
-    m.test_enum_to_long_long(m.ScopedCharEnum.Positive)
-    m.test_enum_to_long_long(m.ScopedBoolEnum.TRUE)
-
-
-def test_duplicate_enum_name():
-    with pytest.raises(ValueError) as excinfo:
-        m.register_bad_enum()
-    assert str(excinfo.value) == 'SimpleEnum: element "ONE" already exists!'
-
-
-def test_char_underlying_enum():  # Issue #1331/PR #1334:
-    assert type(m.ScopedCharEnum.Positive.__int__()) is int
-    assert int(m.ScopedChar16Enum.Zero) == 0
-    assert hash(m.ScopedChar32Enum.Positive) == 1
-    if env.PY2:
-        assert m.ScopedCharEnum.Positive.__getstate__() == 1  # long
-    else:
-        assert type(m.ScopedCharEnum.Positive.__getstate__()) is int
-    assert m.ScopedWCharEnum(1) == m.ScopedWCharEnum.Positive
-    with pytest.raises(TypeError):
-        # Even if the underlying type is char, only an int can be used to construct the enum:
-        m.ScopedCharEnum("0")
-
-
-def test_bool_underlying_enum():
-    assert type(m.ScopedBoolEnum.TRUE.__int__()) is int
-    assert int(m.ScopedBoolEnum.FALSE) == 0
-    assert hash(m.ScopedBoolEnum.TRUE) == 1
-    if env.PY2:
-        assert m.ScopedBoolEnum.TRUE.__getstate__() == 1  # long
-    else:
-        assert type(m.ScopedBoolEnum.TRUE.__getstate__()) is int
-    assert m.ScopedBoolEnum(1) == m.ScopedBoolEnum.TRUE
-    # Enum could construct with a bool
-    # (bool is a strict subclass of int, and False will be converted to 0)
-    assert m.ScopedBoolEnum(False) == m.ScopedBoolEnum.FALSE
-
-
-def test_docstring_signatures():
-    for enum_type in [m.ScopedEnum, m.UnscopedEnum]:
-        for attr in enum_type.__dict__.values():
-            # Issue #2623/PR #2637: Add argument names to enum_ methods
-            assert "arg0" not in (attr.__doc__ or "")

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

@@ -1,119 +0,0 @@
-/*
-    tests/test_eval.cpp -- Usage of eval() and eval_file()
-
-    Copyright (c) 2016 Klemens D. Morgenstern
-
-    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/eval.h>
-
-#include "pybind11_tests.h"
-#include <utility>
-
-TEST_SUBMODULE(eval_, m) {
-    // test_evals
-
-    auto global = py::dict(py::module_::import("__main__").attr("__dict__"));
-
-    m.def("test_eval_statements", [global]() {
-        auto local = py::dict();
-        local["call_test"] = py::cpp_function([&]() -> int {
-            return 42;
-        });
-
-        // Regular string literal
-        py::exec(
-            "message = 'Hello World!'\n"
-            "x = call_test()",
-            global, local
-        );
-
-        // Multi-line raw string literal
-        py::exec(R"(
-            if x == 42:
-                print(message)
-            else:
-                raise RuntimeError
-            )", global, local
-        );
-        auto x = local["x"].cast<int>();
-
-        return x == 42;
-    });
-
-    m.def("test_eval", [global]() {
-        auto local = py::dict();
-        local["x"] = py::int_(42);
-        auto x = py::eval("x", global, local);
-        return x.cast<int>() == 42;
-    });
-
-    m.def("test_eval_single_statement", []() {
-        auto local = py::dict();
-        local["call_test"] = py::cpp_function([&]() -> int {
-            return 42;
-        });
-
-        auto result = py::eval<py::eval_single_statement>("x = call_test()", py::dict(), local);
-        auto x = local["x"].cast<int>();
-        return result.is_none() && x == 42;
-    });
-
-    m.def("test_eval_file", [global](py::str filename) {
-        auto local = py::dict();
-        local["y"] = py::int_(43);
-
-        int val_out = 0;
-        local["call_test2"] = py::cpp_function([&](int value) { val_out = value; });
-
-        auto result = py::eval_file(std::move(filename), global, local);
-        return val_out == 43 && result.is_none();
-    });
-
-    m.def("test_eval_failure", []() {
-        try {
-            py::eval("nonsense code ...");
-        } catch (py::error_already_set &) {
-            return true;
-        }
-        return false;
-    });
-
-    m.def("test_eval_file_failure", []() {
-        try {
-            py::eval_file("non-existing file");
-        } catch (std::exception &) {
-            return true;
-        }
-        return false;
-    });
-
-    // test_eval_empty_globals
-    m.def("eval_empty_globals", [](py::object global) {
-        if (global.is_none())
-            global = py::dict();
-        auto int_class = py::eval("isinstance(42, int)", global);
-        return global;
-    });
-
-    // test_eval_closure
-    m.def("test_eval_closure", []() {
-        py::dict global;
-        global["closure_value"] = 42;
-        py::dict local;
-        local["closure_value"] = 0;
-        py::exec(R"(
-            local_value = closure_value
-
-            def func_global():
-                return closure_value
-
-            def func_local():
-                return local_value
-            )", global, local);
-        return std::make_pair(global, local);
-    });
-}

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

@@ -1,51 +0,0 @@
-# -*- coding: utf-8 -*-
-import os
-
-import pytest
-
-import env  # noqa: F401
-from pybind11_tests import eval_ as m
-
-
-def test_evals(capture):
-    with capture:
-        assert m.test_eval_statements()
-    assert capture == "Hello World!"
-
-    assert m.test_eval()
-    assert m.test_eval_single_statement()
-
-    assert m.test_eval_failure()
-
-
-@pytest.mark.xfail("env.PYPY and not env.PY2", raises=RuntimeError)
-def test_eval_file():
-    filename = os.path.join(os.path.dirname(__file__), "test_eval_call.py")
-    assert m.test_eval_file(filename)
-
-    assert m.test_eval_file_failure()
-
-
-def test_eval_empty_globals():
-    assert "__builtins__" in m.eval_empty_globals(None)
-
-    g = {}
-    assert "__builtins__" in m.eval_empty_globals(g)
-    assert "__builtins__" in g
-
-
-def test_eval_closure():
-    global_, local = m.test_eval_closure()
-
-    assert global_["closure_value"] == 42
-    assert local["closure_value"] == 0
-
-    assert "local_value" not in global_
-    assert local["local_value"] == 0
-
-    assert "func_global" not in global_
-    assert local["func_global"]() == 42
-
-    assert "func_local" not in global_
-    with pytest.raises(NameError):
-        local["func_local"]()

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

@@ -1,5 +0,0 @@
-# -*- coding: utf-8 -*-
-# This file is called from 'test_eval.py'
-
-if "call_test2" in locals():
-    call_test2(y)  # noqa: F821 undefined name