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

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_embed/CMakeLists.txt

@@ -1,47 +0,0 @@
-possibly_uninitialized(PYTHON_MODULE_EXTENSION Python_INTERPRETER_ID)
-
-if("${PYTHON_MODULE_EXTENSION}" MATCHES "pypy" OR "${Python_INTERPRETER_ID}" STREQUAL "PyPy")
-  message(STATUS "Skipping embed test on PyPy")
-  add_custom_target(cpptest) # Dummy target on PyPy. Embedding is not supported.
-  set(_suppress_unused_variable_warning "${DOWNLOAD_CATCH}")
-  return()
-endif()
-
-find_package(Catch 2.13.2)
-
-if(CATCH_FOUND)
-  message(STATUS "Building interpreter tests using Catch v${CATCH_VERSION}")
-else()
-  message(STATUS "Catch not detected. Interpreter tests will be skipped. Install Catch headers"
-                 " manually or use `cmake -DDOWNLOAD_CATCH=ON` to fetch them automatically.")
-  return()
-endif()
-
-find_package(Threads REQUIRED)
-
-add_executable(test_embed catch.cpp test_interpreter.cpp)
-pybind11_enable_warnings(test_embed)
-
-target_link_libraries(test_embed PRIVATE pybind11::embed Catch2::Catch2 Threads::Threads)
-
-if(NOT CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)
-  file(COPY test_interpreter.py DESTINATION "${CMAKE_CURRENT_BINARY_DIR}")
-endif()
-
-add_custom_target(
-  cpptest
-  COMMAND "$<TARGET_FILE:test_embed>"
-  DEPENDS test_embed
-  WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}")
-
-pybind11_add_module(external_module THIN_LTO external_module.cpp)
-set_target_properties(external_module PROPERTIES LIBRARY_OUTPUT_DIRECTORY
-                                                 "${CMAKE_CURRENT_BINARY_DIR}")
-foreach(config ${CMAKE_CONFIGURATION_TYPES})
-  string(TOUPPER ${config} config)
-  set_target_properties(external_module PROPERTIES LIBRARY_OUTPUT_DIRECTORY_${config}
-                                                   "${CMAKE_CURRENT_BINARY_DIR}")
-endforeach()
-add_dependencies(cpptest external_module)
-
-add_dependencies(check cpptest)

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_embed/catch.cpp

@@ -1,22 +0,0 @@
-// The Catch implementation is compiled here. This is a standalone
-// translation unit to avoid recompiling it for every test change.
-
-#include <pybind11/embed.h>
-
-#ifdef _MSC_VER
-// Silence MSVC C++17 deprecation warning from Catch regarding std::uncaught_exceptions (up to catch
-// 2.0.1; this should be fixed in the next catch release after 2.0.1).
-#  pragma warning(disable: 4996)
-#endif
-
-#define CATCH_CONFIG_RUNNER
-#include <catch.hpp>
-
-namespace py = pybind11;
-
-int main(int argc, char *argv[]) {
-    py::scoped_interpreter guard{};
-    auto result = Catch::Session().run(argc, argv);
-
-    return result < 0xff ? result : 0xff;
-}

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_embed/external_module.cpp

@@ -1,23 +0,0 @@
-#include <pybind11/pybind11.h>
-
-namespace py = pybind11;
-
-/* Simple test module/test class to check that the referenced internals data of external pybind11
- * modules aren't preserved over a finalize/initialize.
- */
-
-PYBIND11_MODULE(external_module, m) {
-    class A {
-    public:
-        explicit A(int value) : v{value} {};
-        int v;
-    };
-
-    py::class_<A>(m, "A")
-        .def(py::init<int>())
-        .def_readwrite("value", &A::v);
-
-    m.def("internals_at", []() {
-        return reinterpret_cast<uintptr_t>(&py::detail::get_internals());
-    });
-}

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_embed/test_interpreter.cpp

@@ -1,326 +0,0 @@
-#include <pybind11/embed.h>
-
-#ifdef _MSC_VER
-// Silence MSVC C++17 deprecation warning from Catch regarding std::uncaught_exceptions (up to catch
-// 2.0.1; this should be fixed in the next catch release after 2.0.1).
-#  pragma warning(disable: 4996)
-#endif
-
-#include <catch.hpp>
-
-#include <cstdlib>
-#include <fstream>
-#include <functional>
-#include <thread>
-#include <utility>
-
-namespace py = pybind11;
-using namespace py::literals;
-
-class Widget {
-public:
-    explicit Widget(std::string message) : message(std::move(message)) {}
-    virtual ~Widget() = default;
-
-    std::string the_message() const { return message; }
-    virtual int the_answer() const = 0;
-    virtual std::string argv0() const = 0;
-
-private:
-    std::string message;
-};
-
-class PyWidget final : public Widget {
-    using Widget::Widget;
-
-    int the_answer() const override { PYBIND11_OVERRIDE_PURE(int, Widget, the_answer); }
-    std::string argv0() const override { PYBIND11_OVERRIDE_PURE(std::string, Widget, argv0); }
-};
-
-PYBIND11_EMBEDDED_MODULE(widget_module, m) {
-    py::class_<Widget, PyWidget>(m, "Widget")
-        .def(py::init<std::string>())
-        .def_property_readonly("the_message", &Widget::the_message);
-
-    m.def("add", [](int i, int j) { return i + j; });
-}
-
-PYBIND11_EMBEDDED_MODULE(throw_exception, ) {
-    throw std::runtime_error("C++ Error");
-}
-
-PYBIND11_EMBEDDED_MODULE(throw_error_already_set, ) {
-    auto d = py::dict();
-    d["missing"].cast<py::object>();
-}
-
-TEST_CASE("Pass classes and data between modules defined in C++ and Python") {
-    auto module_ = py::module_::import("test_interpreter");
-    REQUIRE(py::hasattr(module_, "DerivedWidget"));
-
-    auto locals = py::dict("hello"_a="Hello, World!", "x"_a=5, **module_.attr("__dict__"));
-    py::exec(R"(
-        widget = DerivedWidget("{} - {}".format(hello, x))
-        message = widget.the_message
-    )", py::globals(), locals);
-    REQUIRE(locals["message"].cast<std::string>() == "Hello, World! - 5");
-
-    auto py_widget = module_.attr("DerivedWidget")("The question");
-    auto message = py_widget.attr("the_message");
-    REQUIRE(message.cast<std::string>() == "The question");
-
-    const auto &cpp_widget = py_widget.cast<const Widget &>();
-    REQUIRE(cpp_widget.the_answer() == 42);
-}
-
-TEST_CASE("Import error handling") {
-    REQUIRE_NOTHROW(py::module_::import("widget_module"));
-    REQUIRE_THROWS_WITH(py::module_::import("throw_exception"),
-                        "ImportError: C++ Error");
-#if PY_VERSION_HEX >= 0x03030000
-    REQUIRE_THROWS_WITH(py::module_::import("throw_error_already_set"),
-                        Catch::Contains("ImportError: initialization failed"));
-
-    auto locals = py::dict("is_keyerror"_a=false, "message"_a="not set");
-    py::exec(R"(
-        try:
-            import throw_error_already_set
-        except ImportError as e:
-            is_keyerror = type(e.__cause__) == KeyError
-            message = str(e.__cause__)
-    )", py::globals(), locals);
-    REQUIRE(locals["is_keyerror"].cast<bool>() == true);
-    REQUIRE(locals["message"].cast<std::string>() == "'missing'");
-#else
-    REQUIRE_THROWS_WITH(py::module_::import("throw_error_already_set"),
-                        Catch::Contains("ImportError: KeyError"));
-#endif
-}
-
-TEST_CASE("There can be only one interpreter") {
-    static_assert(std::is_move_constructible<py::scoped_interpreter>::value, "");
-    static_assert(!std::is_move_assignable<py::scoped_interpreter>::value, "");
-    static_assert(!std::is_copy_constructible<py::scoped_interpreter>::value, "");
-    static_assert(!std::is_copy_assignable<py::scoped_interpreter>::value, "");
-
-    REQUIRE_THROWS_WITH(py::initialize_interpreter(), "The interpreter is already running");
-    REQUIRE_THROWS_WITH(py::scoped_interpreter(), "The interpreter is already running");
-
-    py::finalize_interpreter();
-    REQUIRE_NOTHROW(py::scoped_interpreter());
-    {
-        auto pyi1 = py::scoped_interpreter();
-        auto pyi2 = std::move(pyi1);
-    }
-    py::initialize_interpreter();
-}
-
-bool has_pybind11_internals_builtin() {
-    auto builtins = py::handle(PyEval_GetBuiltins());
-    return builtins.contains(PYBIND11_INTERNALS_ID);
-};
-
-bool has_pybind11_internals_static() {
-    auto **&ipp = py::detail::get_internals_pp();
-    return (ipp != nullptr) && (*ipp != nullptr);
-}
-
-TEST_CASE("Restart the interpreter") {
-    // Verify pre-restart state.
-    REQUIRE(py::module_::import("widget_module").attr("add")(1, 2).cast<int>() == 3);
-    REQUIRE(has_pybind11_internals_builtin());
-    REQUIRE(has_pybind11_internals_static());
-    REQUIRE(py::module_::import("external_module").attr("A")(123).attr("value").cast<int>() == 123);
-
-    // local and foreign module internals should point to the same internals:
-    REQUIRE(reinterpret_cast<uintptr_t>(*py::detail::get_internals_pp()) ==
-            py::module_::import("external_module").attr("internals_at")().cast<uintptr_t>());
-
-    // Restart the interpreter.
-    py::finalize_interpreter();
-    REQUIRE(Py_IsInitialized() == 0);
-
-    py::initialize_interpreter();
-    REQUIRE(Py_IsInitialized() == 1);
-
-    // Internals are deleted after a restart.
-    REQUIRE_FALSE(has_pybind11_internals_builtin());
-    REQUIRE_FALSE(has_pybind11_internals_static());
-    pybind11::detail::get_internals();
-    REQUIRE(has_pybind11_internals_builtin());
-    REQUIRE(has_pybind11_internals_static());
-    REQUIRE(reinterpret_cast<uintptr_t>(*py::detail::get_internals_pp()) ==
-            py::module_::import("external_module").attr("internals_at")().cast<uintptr_t>());
-
-    // Make sure that an interpreter with no get_internals() created until finalize still gets the
-    // internals destroyed
-    py::finalize_interpreter();
-    py::initialize_interpreter();
-    bool ran = false;
-    py::module_::import("__main__").attr("internals_destroy_test") =
-        py::capsule(&ran, [](void *ran) { py::detail::get_internals(); *static_cast<bool *>(ran) = true; });
-    REQUIRE_FALSE(has_pybind11_internals_builtin());
-    REQUIRE_FALSE(has_pybind11_internals_static());
-    REQUIRE_FALSE(ran);
-    py::finalize_interpreter();
-    REQUIRE(ran);
-    py::initialize_interpreter();
-    REQUIRE_FALSE(has_pybind11_internals_builtin());
-    REQUIRE_FALSE(has_pybind11_internals_static());
-
-    // C++ modules can be reloaded.
-    auto cpp_module = py::module_::import("widget_module");
-    REQUIRE(cpp_module.attr("add")(1, 2).cast<int>() == 3);
-
-    // C++ type information is reloaded and can be used in python modules.
-    auto py_module = py::module_::import("test_interpreter");
-    auto py_widget = py_module.attr("DerivedWidget")("Hello after restart");
-    REQUIRE(py_widget.attr("the_message").cast<std::string>() == "Hello after restart");
-}
-
-TEST_CASE("Subinterpreter") {
-    // Add tags to the modules in the main interpreter and test the basics.
-    py::module_::import("__main__").attr("main_tag") = "main interpreter";
-    {
-        auto m = py::module_::import("widget_module");
-        m.attr("extension_module_tag") = "added to module in main interpreter";
-
-        REQUIRE(m.attr("add")(1, 2).cast<int>() == 3);
-    }
-    REQUIRE(has_pybind11_internals_builtin());
-    REQUIRE(has_pybind11_internals_static());
-
-    /// Create and switch to a subinterpreter.
-    auto main_tstate = PyThreadState_Get();
-    auto sub_tstate = Py_NewInterpreter();
-
-    // Subinterpreters get their own copy of builtins. detail::get_internals() still
-    // works by returning from the static variable, i.e. all interpreters share a single
-    // global pybind11::internals;
-    REQUIRE_FALSE(has_pybind11_internals_builtin());
-    REQUIRE(has_pybind11_internals_static());
-
-    // Modules tags should be gone.
-    REQUIRE_FALSE(py::hasattr(py::module_::import("__main__"), "tag"));
-    {
-        auto m = py::module_::import("widget_module");
-        REQUIRE_FALSE(py::hasattr(m, "extension_module_tag"));
-
-        // Function bindings should still work.
-        REQUIRE(m.attr("add")(1, 2).cast<int>() == 3);
-    }
-
-    // Restore main interpreter.
-    Py_EndInterpreter(sub_tstate);
-    PyThreadState_Swap(main_tstate);
-
-    REQUIRE(py::hasattr(py::module_::import("__main__"), "main_tag"));
-    REQUIRE(py::hasattr(py::module_::import("widget_module"), "extension_module_tag"));
-}
-
-TEST_CASE("Execution frame") {
-    // When the interpreter is embedded, there is no execution frame, but `py::exec`
-    // should still function by using reasonable globals: `__main__.__dict__`.
-    py::exec("var = dict(number=42)");
-    REQUIRE(py::globals()["var"]["number"].cast<int>() == 42);
-}
-
-TEST_CASE("Threads") {
-    // Restart interpreter to ensure threads are not initialized
-    py::finalize_interpreter();
-    py::initialize_interpreter();
-    REQUIRE_FALSE(has_pybind11_internals_static());
-
-    constexpr auto num_threads = 10;
-    auto locals = py::dict("count"_a=0);
-
-    {
-        py::gil_scoped_release gil_release{};
-        REQUIRE(has_pybind11_internals_static());
-
-        auto threads = std::vector<std::thread>();
-        for (auto i = 0; i < num_threads; ++i) {
-            threads.emplace_back([&]() {
-                py::gil_scoped_acquire gil{};
-                locals["count"] = locals["count"].cast<int>() + 1;
-            });
-        }
-
-        for (auto &thread : threads) {
-            thread.join();
-        }
-    }
-
-    REQUIRE(locals["count"].cast<int>() == num_threads);
-}
-
-// Scope exit utility https://stackoverflow.com/a/36644501/7255855
-struct scope_exit {
-    std::function<void()> f_;
-    explicit scope_exit(std::function<void()> f) noexcept : f_(std::move(f)) {}
-    ~scope_exit() { if (f_) f_(); }
-};
-
-TEST_CASE("Reload module from file") {
-    // Disable generation of cached bytecode (.pyc files) for this test, otherwise
-    // Python might pick up an old version from the cache instead of the new versions
-    // of the .py files generated below
-    auto sys = py::module_::import("sys");
-    bool dont_write_bytecode = sys.attr("dont_write_bytecode").cast<bool>();
-    sys.attr("dont_write_bytecode") = true;
-    // Reset the value at scope exit
-    scope_exit reset_dont_write_bytecode([&]() {
-        sys.attr("dont_write_bytecode") = dont_write_bytecode;
-    });
-
-    std::string module_name = "test_module_reload";
-    std::string module_file = module_name + ".py";
-
-    // Create the module .py file
-    std::ofstream test_module(module_file);
-    test_module << "def test():\n";
-    test_module << "    return 1\n";
-    test_module.close();
-    // Delete the file at scope exit
-    scope_exit delete_module_file([&]() {
-        std::remove(module_file.c_str());
-    });
-
-    // Import the module from file
-    auto module_ = py::module_::import(module_name.c_str());
-    int result = module_.attr("test")().cast<int>();
-    REQUIRE(result == 1);
-
-    // Update the module .py file with a small change
-    test_module.open(module_file);
-    test_module << "def test():\n";
-    test_module << "    return 2\n";
-    test_module.close();
-
-    // Reload the module
-    module_.reload();
-    result = module_.attr("test")().cast<int>();
-    REQUIRE(result == 2);
-}
-
-TEST_CASE("sys.argv gets initialized properly") {
-    py::finalize_interpreter();
-    {
-        py::scoped_interpreter default_scope;
-        auto module = py::module::import("test_interpreter");
-        auto py_widget = module.attr("DerivedWidget")("The question");
-        const auto &cpp_widget = py_widget.cast<const Widget &>();
-        REQUIRE(cpp_widget.argv0().empty());
-    }
-
-    {
-        char *argv[] = {strdup("a.out")};
-        py::scoped_interpreter argv_scope(true, 1, argv);
-        std::free(argv[0]);
-        auto module = py::module::import("test_interpreter");
-        auto py_widget = module.attr("DerivedWidget")("The question");
-        const auto &cpp_widget = py_widget.cast<const Widget &>();
-        REQUIRE(cpp_widget.argv0() == "a.out");
-    }
-    py::initialize_interpreter();
-}

xcoll/scattering_routines/geant4/collimasim/lib/pybind11/tests/test_embed/test_interpreter.py

@@ -1,15 +0,0 @@
-# -*- coding: utf-8 -*-
-import sys
-
-from widget_module import Widget
-
-
-class DerivedWidget(Widget):
-    def __init__(self, message):
-        super(DerivedWidget, self).__init__(message)
-
-    def the_answer(self):
-        return 42
-
-    def argv0(self):
-        return sys.argv[0]

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

@@ -1,148 +0,0 @@
-/*
-    tests/test_enums.cpp -- enumerations
-
-    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"
-
-TEST_SUBMODULE(enums, m) {
-    // test_unscoped_enum
-    enum UnscopedEnum {
-        EOne = 1,
-        ETwo,
-        EThree
-    };
-    py::enum_<UnscopedEnum>(m, "UnscopedEnum", py::arithmetic(), "An unscoped enumeration")
-        .value("EOne", EOne, "Docstring for EOne")
-        .value("ETwo", ETwo, "Docstring for ETwo")
-        .value("EThree", EThree, "Docstring for EThree")
-        .export_values();
-
-    // test_scoped_enum
-    enum class ScopedEnum {
-        Two = 2,
-        Three
-    };
-    py::enum_<ScopedEnum>(m, "ScopedEnum", py::arithmetic())
-        .value("Two", ScopedEnum::Two)
-        .value("Three", ScopedEnum::Three);
-
-    m.def("test_scoped_enum", [](ScopedEnum z) {
-        return "ScopedEnum::" + std::string(z == ScopedEnum::Two ? "Two" : "Three");
-    });
-
-    // test_binary_operators
-    enum Flags {
-        Read = 4,
-        Write = 2,
-        Execute = 1
-    };
-    py::enum_<Flags>(m, "Flags", py::arithmetic())
-        .value("Read", Flags::Read)
-        .value("Write", Flags::Write)
-        .value("Execute", Flags::Execute)
-        .export_values();
-
-    // test_implicit_conversion
-    class ClassWithUnscopedEnum {
-    public:
-        enum EMode {
-            EFirstMode = 1,
-            ESecondMode
-        };
-
-        static EMode test_function(EMode mode) {
-            return mode;
-        }
-    };
-    py::class_<ClassWithUnscopedEnum> exenum_class(m, "ClassWithUnscopedEnum");
-    exenum_class.def_static("test_function", &ClassWithUnscopedEnum::test_function);
-    py::enum_<ClassWithUnscopedEnum::EMode>(exenum_class, "EMode")
-        .value("EFirstMode", ClassWithUnscopedEnum::EFirstMode)
-        .value("ESecondMode", ClassWithUnscopedEnum::ESecondMode)
-        .export_values();
-
-    // test_enum_to_int
-    m.def("test_enum_to_int", [](int) { });
-    m.def("test_enum_to_uint", [](uint32_t) { });
-    m.def("test_enum_to_long_long", [](long long) { });
-
-    // test_duplicate_enum_name
-    enum SimpleEnum
-    {
-        ONE, TWO, THREE
-    };
-
-    m.def("register_bad_enum", [m]() {
-        py::enum_<SimpleEnum>(m, "SimpleEnum")
-            .value("ONE", SimpleEnum::ONE)          //NOTE: all value function calls are called with the same first parameter value
-            .value("ONE", SimpleEnum::TWO)
-            .value("ONE", SimpleEnum::THREE)
-            .export_values();
-    });
-
-    // test_enum_scalar
-    enum UnscopedUCharEnum : unsigned char {};
-    enum class ScopedShortEnum : short {};
-    enum class ScopedLongEnum : long {};
-    enum UnscopedUInt64Enum : std::uint64_t {};
-    static_assert(py::detail::all_of<
-        std::is_same<py::enum_<UnscopedUCharEnum>::Scalar, unsigned char>,
-        std::is_same<py::enum_<ScopedShortEnum>::Scalar, short>,
-        std::is_same<py::enum_<ScopedLongEnum>::Scalar, long>,
-        std::is_same<py::enum_<UnscopedUInt64Enum>::Scalar, std::uint64_t>
-    >::value, "Error during the deduction of enum's scalar type with normal integer underlying");
-
-    // test_enum_scalar_with_char_underlying
-    enum class ScopedCharEnum   : char     { Zero, Positive };
-    enum class ScopedWCharEnum  : wchar_t  { Zero, Positive };
-    enum class ScopedChar32Enum : char32_t { Zero, Positive };
-    enum class ScopedChar16Enum : char16_t { Zero, Positive };
-
-    // test the scalar of char type enums according to chapter 'Character types'
-    // from https://en.cppreference.com/w/cpp/language/types
-    static_assert(py::detail::any_of<
-        std::is_same<py::enum_<ScopedCharEnum>::Scalar, signed char>, // e.g. gcc on x86
-        std::is_same<py::enum_<ScopedCharEnum>::Scalar, unsigned char>  // e.g. arm linux
-    >::value, "char should be cast to either signed char or unsigned char");
-    static_assert(
-        sizeof(py::enum_<ScopedWCharEnum>::Scalar) == 2 ||
-        sizeof(py::enum_<ScopedWCharEnum>::Scalar) == 4
-    , "wchar_t should be either 16 bits (Windows) or 32 (everywhere else)");
-    static_assert(py::detail::all_of<
-        std::is_same<py::enum_<ScopedChar32Enum>::Scalar, std::uint_least32_t>,
-        std::is_same<py::enum_<ScopedChar16Enum>::Scalar, std::uint_least16_t>
-    >::value, "char32_t, char16_t (and char8_t)'s size, signedness, and alignment is determined");
-#if defined(PYBIND11_HAS_U8STRING)
-    enum class ScopedChar8Enum : char8_t { Zero, Positive };
-    static_assert(std::is_same<py::enum_<ScopedChar8Enum>::Scalar, unsigned char>::value);
-#endif
-
-    // test_char_underlying_enum
-    py::enum_<ScopedCharEnum>(m, "ScopedCharEnum")
-        .value("Zero", ScopedCharEnum::Zero)
-        .value("Positive", ScopedCharEnum::Positive);
-    py::enum_<ScopedWCharEnum>(m, "ScopedWCharEnum")
-        .value("Zero", ScopedWCharEnum::Zero)
-        .value("Positive", ScopedWCharEnum::Positive);
-    py::enum_<ScopedChar32Enum>(m, "ScopedChar32Enum")
-        .value("Zero", ScopedChar32Enum::Zero)
-        .value("Positive", ScopedChar32Enum::Positive);
-    py::enum_<ScopedChar16Enum>(m, "ScopedChar16Enum")
-        .value("Zero", ScopedChar16Enum::Zero)
-        .value("Positive", ScopedChar16Enum::Positive);
-
-    // test_bool_underlying_enum
-    enum class ScopedBoolEnum : bool { FALSE, TRUE };
-
-    // bool is unsigned (std::is_signed returns false) and 1-byte long, so represented with u8
-    static_assert(std::is_same<py::enum_<ScopedBoolEnum>::Scalar, std::uint8_t>::value, "");
-
-    py::enum_<ScopedBoolEnum>(m, "ScopedBoolEnum")
-        .value("FALSE", ScopedBoolEnum::FALSE)
-        .value("TRUE", ScopedBoolEnum::TRUE);
-}