CLUEstering 2.2.7__tar.gz → 2.2.8__tar.gz

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/CLUEstering/alpaka/CLUE/CLUEAlgoAlpaka.h

@@ -232,6 +232,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
     // Wait for all the operations in the queue to finish
     alpaka::wait(queue_);
 
+#ifdef DEBUG
     alpaka::memcpy(queue_,
                    cms::alpakatools::make_host_view(h_points.m_rho.data(), h_points.n),
                    d_points.rho,
@@ -245,6 +246,7 @@ namespace ALPAKA_ACCELERATOR_NAMESPACE {
         cms::alpakatools::make_host_view(h_points.m_nearestHigher.data(), h_points.n),
         d_points.nearest_higher,
         static_cast<uint32_t>(h_points.n));
+#endif
     alpaka::memcpy(
         queue_,
         cms::alpakatools::make_host_view(h_points.m_clusterIndex.data(), h_points.n),

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/CLUEstering.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CLUEstering
-Version: 2.2.7
+Version: 2.2.8
 Summary: A library that generalizes the original 2-dimensional CLUE
 Author: Simone Balducci
 Author-email: simone.balducci00@gmail.com

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/CMakeLists.txt

@@ -10,6 +10,7 @@ if(NOT CMAKE_BUILD_TYPE)
 endif()
 
 if(${CMAKE_BUILD_TYPE} STREQUAL "Debug")
+  add_compile_definitions(DEBUG)
   set(CMAKE_CXX_FLAGS "-Wall -Wextra -g -O0")
 elseif(${CMAKE_BUILD_TYPE} STREQUAL "Release")
   set(CMAKE_CXX_FLAGS "-O2")

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: CLUEstering
-Version: 2.2.7
+Version: 2.2.8
 Summary: A library that generalizes the original 2-dimensional CLUE
 Author: Simone Balducci
 Author-email: simone.balducci00@gmail.com

CLUEstering-2.2.8/extern/alpaka/.git

@@ -0,0 +1 @@
+gitdir: ../../../worktrees/main/modules/extern/alpaka

CLUEstering-2.2.8/extern/pybind11/.git

@@ -0,0 +1 @@
+gitdir: ../../../worktrees/main/modules/extern/pybind11

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_builtin_casters.cpp

@@ -95,7 +95,7 @@ TEST_SUBMODULE(builtin_casters, m) {
     } // 𝐀, utf16
     else {
         wstr.push_back((wchar_t) mathbfA32);
-    } // 𝐀, utf32
+    }                     // 𝐀, utf32
     wstr.push_back(0x7a); // z
 
     m.def("good_utf8_string", []() {
@@ -104,9 +104,10 @@ TEST_SUBMODULE(builtin_casters, m) {
     m.def("good_utf16_string", [=]() {
         return std::u16string({b16, ib16, cake16_1, cake16_2, mathbfA16_1, mathbfA16_2, z16});
     }); // b‽🎂𝐀z
-    m.def("good_utf32_string",
-          [=]() { return std::u32string({a32, mathbfA32, cake32, ib32, z32}); }); // a𝐀🎂‽z
-    m.def("good_wchar_string", [=]() { return wstr; });                           // a‽𝐀z
+    m.def("good_utf32_string", [=]() {
+        return std::u32string({a32, mathbfA32, cake32, ib32, z32});
+    });                                                 // a𝐀🎂‽z
+    m.def("good_wchar_string", [=]() { return wstr; }); // a‽𝐀z
     m.def("bad_utf8_string", []() {
         return std::string("abc\xd0"
                            "def");
@@ -116,8 +117,9 @@ TEST_SUBMODULE(builtin_casters, m) {
     // UnicodeDecodeError
     m.def("bad_utf32_string", [=]() { return std::u32string({a32, char32_t(0xd800), z32}); });
     if (sizeof(wchar_t) == 2) {
-        m.def("bad_wchar_string",
-              [=]() { return std::wstring({wchar_t(0x61), wchar_t(0xd800)}); });
+        m.def("bad_wchar_string", [=]() {
+            return std::wstring({wchar_t(0x61), wchar_t(0xd800)});
+        });
     }
     m.def("u8_Z", []() -> char { return 'Z'; });
     m.def("u8_eacute", []() -> char { return '\xe9'; });
@@ -234,7 +236,8 @@ TEST_SUBMODULE(builtin_casters, m) {
 
     // test_int_convert
     m.def("int_passthrough", [](int arg) { return arg; });
-    m.def("int_passthrough_noconvert", [](int arg) { return arg; }, py::arg{}.noconvert());
+    m.def(
+        "int_passthrough_noconvert", [](int arg) { return arg; }, py::arg{}.noconvert());
 
     // test_tuple
     m.def(
@@ -299,7 +302,8 @@ TEST_SUBMODULE(builtin_casters, m) {
 
     // test_bool_caster
     m.def("bool_passthrough", [](bool arg) { return arg; });
-    m.def("bool_passthrough_noconvert", [](bool arg) { return arg; }, py::arg{}.noconvert());
+    m.def(
+        "bool_passthrough_noconvert", [](bool arg) { return arg; }, py::arg{}.noconvert());
 
     // TODO: This should be disabled and fixed in future Intel compilers
 #if !defined(__INTEL_COMPILER)
@@ -307,7 +311,8 @@ TEST_SUBMODULE(builtin_casters, m) {
     // When compiled with the Intel compiler, this results in segmentation faults when importing
     // the module. Tested with icc (ICC) 2021.1 Beta 20200827, this should be tested again when
     // a newer version of icc is available.
-    m.def("bool_passthrough_noconvert2", [](bool arg) { return arg; }, py::arg().noconvert());
+    m.def(
+        "bool_passthrough_noconvert2", [](bool arg) { return arg; }, py::arg().noconvert());
 #endif
 
     // test_reference_wrapper

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_call_policies.cpp

@@ -63,8 +63,10 @@ TEST_SUBMODULE(call_policies, m) {
         .def("returnNullChildKeepAliveParent", &Parent::returnNullChild, py::keep_alive<0, 1>())
         .def_static("staticFunction", &Parent::staticFunction, py::keep_alive<1, 0>());
 
-    m.def("free_function", [](Parent *, Child *) {}, py::keep_alive<1, 2>());
-    m.def("invalid_arg_index", [] {}, py::keep_alive<0, 1>());
+    m.def(
+        "free_function", [](Parent *, Child *) {}, py::keep_alive<1, 2>());
+    m.def(
+        "invalid_arg_index", [] {}, py::keep_alive<0, 1>());
 
 #if !defined(PYPY_VERSION)
     // test_alive_gc

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_class.cpp

@@ -403,7 +403,7 @@ TEST_SUBMODULE(class_, m) {
         // [workaround(intel)] = default does not work here
         // Removing or defaulting this destructor results in linking errors with the Intel compiler
         // (in Debug builds only, tested with icpc (ICC) 2021.1 Beta 20200827)
-        ~PublicistB() override {}; // NOLINT(modernize-use-equals-default)
+        ~PublicistB() override{}; // NOLINT(modernize-use-equals-default)
         using ProtectedB::foo;
         using ProtectedB::get_self;
         using ProtectedB::void_foo;
@@ -461,7 +461,8 @@ TEST_SUBMODULE(class_, m) {
     py::class_<Nested>(base, "Nested")
         .def(py::init<>())
         .def("fn", [](Nested &, int, NestBase &, Nested &) {})
-        .def("fa", [](Nested &, int, NestBase &, Nested &) {}, "a"_a, "b"_a, "c"_a);
+        .def(
+            "fa", [](Nested &, int, NestBase &, Nested &) {}, "a"_a, "b"_a, "c"_a);
     base.def("g", [](NestBase &, Nested &) {});
     base.def("h", []() { return NestBase(); });
 

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_copy_move.cpp

@@ -289,7 +289,8 @@ TEST_SUBMODULE(copy_move_policies, m) {
         "get_moveissue1",
         [](int i) { return std::unique_ptr<MoveIssue1>(new MoveIssue1(i)); },
         py::return_value_policy::move);
-    m.def("get_moveissue2", [](int i) { return MoveIssue2(i); }, py::return_value_policy::move);
+    m.def(
+        "get_moveissue2", [](int i) { return MoveIssue2(i); }, py::return_value_policy::move);
 
     // Make sure that cast from pytype rvalue to other pytype works
     m.def("get_pytype_rvalue_castissue", [](double i) { return py::float_(i).cast<py::int_>(); });

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_custom_type_casters.cpp

@@ -175,10 +175,14 @@ TEST_SUBMODULE(custom_type_casters, m) {
         py::arg_v(nullptr, ArgInspector1()).noconvert(true),
         py::arg() = ArgAlwaysConverts());
 
-    m.def("floats_preferred", [](double f) { return 0.5 * f; }, "f"_a);
-    m.def("floats_only", [](double f) { return 0.5 * f; }, "f"_a.noconvert());
-    m.def("ints_preferred", [](int i) { return i / 2; }, "i"_a);
-    m.def("ints_only", [](int i) { return i / 2; }, "i"_a.noconvert());
+    m.def(
+        "floats_preferred", [](double f) { return 0.5 * f; }, "f"_a);
+    m.def(
+        "floats_only", [](double f) { return 0.5 * f; }, "f"_a.noconvert());
+    m.def(
+        "ints_preferred", [](int i) { return i / 2; }, "i"_a);
+    m.def(
+        "ints_only", [](int i) { return i / 2; }, "i"_a.noconvert());
 
     // test_custom_caster_destruction
     // Test that `take_ownership` works on types with a custom type caster when given a pointer

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_docstring_options.cpp

@@ -15,26 +15,37 @@ TEST_SUBMODULE(docstring_options, m) {
         py::options options;
         options.disable_function_signatures();
 
-        m.def("test_function1", [](int, int) {}, py::arg("a"), py::arg("b"));
-        m.def("test_function2", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
-
-        m.def("test_overloaded1", [](int) {}, py::arg("i"), "Overload docstring");
-        m.def("test_overloaded1", [](double) {}, py::arg("d"));
-
-        m.def("test_overloaded2", [](int) {}, py::arg("i"), "overload docstring 1");
-        m.def("test_overloaded2", [](double) {}, py::arg("d"), "overload docstring 2");
-
-        m.def("test_overloaded3", [](int) {}, py::arg("i"));
-        m.def("test_overloaded3", [](double) {}, py::arg("d"), "Overload docstr");
+        m.def(
+            "test_function1", [](int, int) {}, py::arg("a"), py::arg("b"));
+        m.def(
+            "test_function2", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
+
+        m.def(
+            "test_overloaded1", [](int) {}, py::arg("i"), "Overload docstring");
+        m.def(
+            "test_overloaded1", [](double) {}, py::arg("d"));
+
+        m.def(
+            "test_overloaded2", [](int) {}, py::arg("i"), "overload docstring 1");
+        m.def(
+            "test_overloaded2", [](double) {}, py::arg("d"), "overload docstring 2");
+
+        m.def(
+            "test_overloaded3", [](int) {}, py::arg("i"));
+        m.def(
+            "test_overloaded3", [](double) {}, py::arg("d"), "Overload docstr");
 
         options.enable_function_signatures();
 
-        m.def("test_function3", [](int, int) {}, py::arg("a"), py::arg("b"));
-        m.def("test_function4", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
+        m.def(
+            "test_function3", [](int, int) {}, py::arg("a"), py::arg("b"));
+        m.def(
+            "test_function4", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
 
         options.disable_function_signatures().disable_user_defined_docstrings();
 
-        m.def("test_function5", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
+        m.def(
+            "test_function5", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
 
         {
             py::options nested_options;
@@ -48,7 +59,8 @@ TEST_SUBMODULE(docstring_options, m) {
         }
     }
 
-    m.def("test_function7", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
+    m.def(
+        "test_function7", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
 
     {
         py::options options;

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_eigen_matrix.cpp

@@ -340,10 +340,12 @@ TEST_SUBMODULE(eigen_matrix, m) {
     if (have_numpy) {
         py::module_::import("numpy");
         Eigen::Matrix<double, 3, 3> defaultMatrix = Eigen::Matrix3d::Identity();
-        m.def("defaults_mat", [](const Eigen::Matrix3d &) {}, py::arg("mat") = defaultMatrix);
+        m.def(
+            "defaults_mat", [](const Eigen::Matrix3d &) {}, py::arg("mat") = defaultMatrix);
 
         Eigen::VectorXd defaultVector = Eigen::VectorXd::Ones(32);
-        m.def("defaults_vec", [](const Eigen::VectorXd &) {}, py::arg("vec") = defaultMatrix);
+        m.def(
+            "defaults_vec", [](const Eigen::VectorXd &) {}, py::arg("vec") = defaultMatrix);
     }
     // test_sparse, test_sparse_signature
     m.def("sparse_r", [mat]() -> SparseMatrixR {

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_kwargs_and_defaults.cpp

@@ -22,7 +22,8 @@ TEST_SUBMODULE(kwargs_and_defaults, m) {
     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!"));
+    m.def(
+        "kw_func3", [](const char *) {}, py::arg("data") = std::string("Hello world!"));
 
     /* A fancier default argument */
     std::vector<int> list{{13, 17}};
@@ -78,12 +79,14 @@ TEST_SUBMODULE(kwargs_and_defaults, m) {
         "kw_lb_func5",
         [](const CustomRepr &) {},
         py::arg("custom") = CustomRepr("array([[A, B],\r  [C, D]])"));
-    m.def("kw_lb_func6", [](const CustomRepr &) {}, py::arg("custom") = CustomRepr(" \v\t "));
+    m.def(
+        "kw_lb_func6", [](const CustomRepr &) {}, py::arg("custom") = CustomRepr(" \v\t "));
     m.def(
         "kw_lb_func7",
         [](const std::string &) {},
         py::arg("str_arg") = "First line.\n  Second line.");
-    m.def("kw_lb_func8", [](const CustomRepr &) {}, py::arg("custom") = CustomRepr(""));
+    m.def(
+        "kw_lb_func8", [](const CustomRepr &) {}, py::arg("custom") = CustomRepr(""));
 
     // test_args_and_kwargs
     m.def("args_function", [](py::args args) -> py::tuple {
@@ -276,9 +279,11 @@ TEST_SUBMODULE(kwargs_and_defaults, m) {
     // These should fail to compile:
 #ifdef PYBIND11_NEVER_DEFINED_EVER
     // argument annotations are required when using kw_only
-    m.def("bad_kw_only1", [](int) {}, py::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);
+    m.def(
+        "bad_kw_only2", [](int i, py::args) {}, py::kw_only(), "i"_a);
 #endif
 
     // test_function_signatures (along with most of the above)

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_methods_and_attributes.cpp

@@ -374,7 +374,8 @@ TEST_SUBMODULE(methods_and_attributes, m) {
     m.def("overload_order", [](const std::string &) { return 1; });
     m.def("overload_order", [](const std::string &) { return 2; });
     m.def("overload_order", [](int) { return 3; });
-    m.def("overload_order", [](int) { return 4; }, py::prepend{});
+    m.def(
+        "overload_order", [](int) { return 4; }, py::prepend{});
 
 #if !defined(PYPY_VERSION)
     // test_dynamic_attributes

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_numpy_array.cpp

@@ -287,7 +287,8 @@ TEST_SUBMODULE(numpy_array, sm) {
     // [workaround(intel)] ICC 20/21 breaks with py::arg().stuff, using py::arg{}.stuff works.
 
     // Only accept the exact types:
-    sm.def("overloaded3", [](const py::array_t<int> &) { return "int"; }, py::arg{}.noconvert());
+    sm.def(
+        "overloaded3", [](const py::array_t<int> &) { return "int"; }, py::arg{}.noconvert());
     sm.def(
         "overloaded3",
         [](const py::array_t<double> &) { return "double"; },
@@ -443,8 +444,9 @@ TEST_SUBMODULE(numpy_array, sm) {
     });
 
     // resize to 3D array with each dimension = N
-    sm.def("array_resize3",
-           [](py::array_t<double> a, size_t N, bool refcheck) { a.resize({N, N, N}, refcheck); });
+    sm.def("array_resize3", [](py::array_t<double> a, size_t N, bool refcheck) {
+        a.resize({N, N, N}, refcheck);
+    });
 
     // test_array_create_and_resize
     // return 2D array with Nrows = Ncols = N
@@ -458,8 +460,9 @@ TEST_SUBMODULE(numpy_array, sm) {
     sm.def("array_view",
            [](py::array_t<uint8_t> a, const std::string &dtype) { return a.view(dtype); });
 
-    sm.def("reshape_initializer_list",
-           [](py::array_t<int> a, size_t N, size_t M, size_t O) { return a.reshape({N, M, O}); });
+    sm.def("reshape_initializer_list", [](py::array_t<int> a, size_t N, size_t M, size_t O) {
+        return a.reshape({N, M, O});
+    });
     sm.def("reshape_tuple", [](py::array_t<int> a, const std::vector<int> &new_shape) {
         return a.reshape(new_shape);
     });
@@ -468,7 +471,8 @@ TEST_SUBMODULE(numpy_array, sm) {
            [](const py::array &a) { return a[py::make_tuple(0, py::ellipsis(), 0)]; });
 
     // test_argument_conversions
-    sm.def("accept_double", [](const py::array_t<double, 0> &) {}, py::arg("a"));
+    sm.def(
+        "accept_double", [](const py::array_t<double, 0> &) {}, py::arg("a"));
     sm.def(
         "accept_double_forcecast",
         [](const py::array_t<double, py::array::forcecast> &) {},
@@ -489,7 +493,8 @@ TEST_SUBMODULE(numpy_array, sm) {
         "accept_double_f_style_forcecast",
         [](const py::array_t<double, py::array::forcecast | py::array::f_style> &) {},
         py::arg("a"));
-    sm.def("accept_double_noconvert", [](const py::array_t<double, 0> &) {}, "a"_a.noconvert());
+    sm.def(
+        "accept_double_noconvert", [](const py::array_t<double, 0> &) {}, "a"_a.noconvert());
     sm.def(
         "accept_double_forcecast_noconvert",
         [](const py::array_t<double, py::array::forcecast> &) {},

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_numpy_dtypes.cpp

@@ -157,7 +157,7 @@ py::array mkarray_via_buffer(size_t n) {
     do {                                                                                          \
         (s).bool_ = (i) % 2 != 0;                                                                 \
         (s).uint_ = (uint32_t) (i);                                                               \
-        (s).float_ = (float) (i) * 1.5f;                                                          \
+        (s).float_ = (float) (i) *1.5f;                                                           \
         (s).ldbl_ = (long double) (i) * -2.5L;                                                    \
     } while (0)
 
@@ -348,7 +348,7 @@ TEST_SUBMODULE(numpy_dtypes, m) {
     // is not a POD type
     struct NotPOD {
         std::string v;
-        NotPOD() : v("hi") {};
+        NotPOD() : v("hi"){};
     };
     PYBIND11_NUMPY_DTYPE(NotPOD, v);
 #endif

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_stl.cpp

@@ -78,7 +78,7 @@ struct hash<TplCtorClass> {
 template <template <typename> class OptionalImpl, typename T>
 struct OptionalHolder {
     // NOLINTNEXTLINE(modernize-use-equals-default): breaks GCC 4.8
-    OptionalHolder() {};
+    OptionalHolder(){};
     bool member_initialized() const { return member && member->initialized; }
     OptionalImpl<T> member = T{};
 };
@@ -217,8 +217,9 @@ TEST_SUBMODULE(stl, m) {
     // NB: map and set keys are `const`, so while we technically do move them (as `const Type &&`),
     // casters don't typically do anything with that, which means they fall to the `const Type &`
     // caster.
-    m.def("cast_rv_map",
-          []() { return std::unordered_map<std::string, RValueCaster>{{"a", RValueCaster{}}}; });
+    m.def("cast_rv_map", []() {
+        return std::unordered_map<std::string, RValueCaster>{{"a", RValueCaster{}}};
+    });
     m.def("cast_rv_nested", []() {
         std::vector<std::array<std::list<std::unordered_map<std::string, RValueCaster>>, 2>> v;
         v.emplace_back();           // add an array
@@ -496,7 +497,8 @@ TEST_SUBMODULE(stl, m) {
     });
 
     // test_stl_pass_by_pointer
-    m.def("stl_pass_by_pointer", [](std::vector<int> *v) { return *v; }, "v"_a = nullptr);
+    m.def(
+        "stl_pass_by_pointer", [](std::vector<int> *v) { return *v; }, "v"_a = nullptr);
 
     // #1258: pybind11/stl.h converts string to vector<string>
     m.def("func_with_string_or_vector_string_arg_overload",

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_stl_binders.cpp

@@ -190,6 +190,7 @@ TEST_SUBMODULE(stl_binders, m) {
     PYBIND11_NUMPY_DTYPE(VStruct, w, x, y, z);
     py::class_<VStruct>(m, "VStruct").def_readwrite("x", &VStruct::x);
     py::bind_vector<std::vector<VStruct>>(m, "VectorStruct", py::buffer_protocol());
-    m.def("get_vectorstruct",
-          [] { return std::vector<VStruct>{{false, 5, 3.0, true}, {true, 30, -1e4, false}}; });
+    m.def("get_vectorstruct", [] {
+        return std::vector<VStruct>{{false, 5, 3.0, true}, {true, 30, -1e4, false}};
+    });
 }

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/extern/pybind11/tests/test_thread.cpp

@@ -20,7 +20,7 @@ namespace py = pybind11;
 namespace {
 
 struct IntStruct {
-    explicit IntStruct(int v) : value(v) {};
+    explicit IntStruct(int v) : value(v){};
     ~IntStruct() { value = -value; }
     IntStruct(const IntStruct &) = default;
     IntStruct &operator=(const IntStruct &) = default;

{CLUEstering-2.2.7 → CLUEstering-2.2.8}/setup.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from setuptools import setup
 import subprocess
 
-__version__ = "2.2.7"
+__version__ = "2.2.8"
 
 this_directory = Path(__file__).parent
 long_description = (this_directory/'README.md').read_text()

CLUEstering-2.2.7/extern/alpaka/.git

@@ -1 +0,0 @@
-gitdir: ../../.git/modules/extern/alpaka

CLUEstering-2.2.7/extern/pybind11/.git

@@ -1 +0,0 @@
-gitdir: ../../.git/modules/extern/pybind11