Implement custom Pybind11 type casters to improve the API readability.

Improve conversion implementation by removing intermediate conversions.

Author: breyerml

bindings/Python/conversion_from_python.hpp

@@ -12,15 +12,15 @@
 #include "plssvm/detail/type_traits.hpp"       // plssvm::detail::remove_cvref_t
 #include "plssvm/file_format_types.hpp"        // plssvm::file_format_type
 
-#include "bindings/Python/conversion_from_python.hpp"    // plssvm::bindings::python::util::{pyobject_to_matrix, pyobject_to_vector}
-#include "bindings/Python/conversion_to_python.hpp"      // plssvm::bindings::python::util::{matrix_to_pyarray, vector_to_pyarray}
-#include "bindings/Python/data_set/variant_wrapper.hpp"  // plssvm::bindings::python::util::classification_data_set_wrapper
-#include "bindings/Python/utility.hpp"                   // plssvm::bindings::python::util::{create_instance, python_type_name_mapping}
+#include "bindings/Python/data_set/variant_wrapper.hpp"                 // plssvm::bindings::python::util::classification_data_set_wrapper
+#include "bindings/Python/type_caster/label_vector_wrapper_caster.hpp"  // a custom Pybind11 type caster for a plssvm::bindings::python::util::label_vector_wrapper
+#include "bindings/Python/type_caster/matrix_type_caster.hpp"           // a custom Pybind11 type caster for a plssvm::matrix
+#include "bindings/Python/utility.hpp"                                  // plssvm::bindings::python::util::{create_instance, python_type_name_mapping, vector_to_pyarray}
 
 #include "fmt/format.h"         // fmt::format
 #include "fmt/ranges.h"         // fmt::join
 #include "pybind11/numpy.h"     // py::array_t, py::array
-#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::pos_only, py::object, py::attribute_error
+#include "pybind11/pybind11.h"  // py::module_, py::class_, py::init, py::arg, py::pos_only, py::attribute_error
 #include "pybind11/pytypes.h"   // py::type
 #include "pybind11/stl.h"       // support for STL types
 
@@ -57,21 +57,18 @@ void init_classification_data_set(py::module_ &m) {
              py::arg("type") = std::nullopt,
              py::arg("format") = plssvm::file_format_type::libsvm,
              py::arg("scaler") = std::nullopt)
-        .def(py::init([](py::object data, const std::optional<py::type> type, const std::optional<plssvm::min_max_scaler> scaler) {
-                 // convert the data py::object to a plssvm::aos_matrix
-                 auto [data_matrix, opt_feature_names] = plssvm::bindings::python::util::pyobject_to_matrix(data);
-
+        .def(py::init([](plssvm::soa_matrix<plssvm::real_type> data, const std::optional<py::type> type, const std::optional<plssvm::min_max_scaler> scaler) {
                  if (type.has_value()) {
                      if (scaler.has_value()) {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::classification_data_set, typename classification_data_set_wrapper::possible_data_set_types>(type.value(), std::move(data_matrix), scaler.value()));
+                         return std::make_unique<classification_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::classification_data_set, typename classification_data_set_wrapper::possible_data_set_types>(type.value(), std::move(data), scaler.value()));
                      } else {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::classification_data_set, typename classification_data_set_wrapper::possible_data_set_types>(type.value(), std::move(data_matrix)));
+                         return std::make_unique<classification_data_set_wrapper>(plssvm::bindings::python::util::create_instance<plssvm::classification_data_set, typename classification_data_set_wrapper::possible_data_set_types>(type.value(), std::move(data)));
                      }
                  } else {
                      if (scaler.has_value()) {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<std::string>{ std::move(data_matrix), scaler.value() });
+                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<std::string>{ std::move(data), scaler.value() });
                      } else {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<std::string>{ std::move(data_matrix) });
+                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<std::string>{ std::move(data) });
                      }
                  }
              }),
@@ -80,29 +77,24 @@ void init_classification_data_set(py::module_ &m) {
              py::pos_only(),
              py::arg("type") = std::nullopt,
              py::arg("scaler") = std::nullopt)
-        .def(py::init([](py::object data, py::object labels, const std::optional<plssvm::min_max_scaler> scaler) {
-                 // convert the data py::object to a plssvm::aos_matrix
-                 auto [data_matrix, opt_feature_names] = plssvm::bindings::python::util::pyobject_to_matrix(data);
-                 // convert the labels to a std::vector
-                 auto [labels_vector_variant, dtype] = plssvm::bindings::python::util::pyobject_to_vector<typename classification_data_set_wrapper::possible_vector_types>(labels);
-
-                 return std::visit([&data_matrix = data_matrix, &dtype = dtype, &scaler](auto &&labels_vector) {
+        .def(py::init([](plssvm::soa_matrix<plssvm::real_type> data, plssvm::bindings::python::util::label_vector_wrapper<typename classification_data_set_wrapper::possible_vector_types> labels, const std::optional<plssvm::min_max_scaler> scaler) {
+                 return std::visit([&](auto &&labels_vector) {
                      using label_type = typename plssvm::detail::remove_cvref_t<decltype(labels_vector)>::value_type;
                      if (scaler.has_value()) {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<label_type>(std::move(data_matrix), std::move(labels_vector), scaler.value()));
+                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<label_type>(std::move(data), std::move(labels_vector), scaler.value()));
                      } else {
-                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<label_type>(std::move(data_matrix), std::move(labels_vector)));
+                         return std::make_unique<classification_data_set_wrapper>(plssvm::classification_data_set<label_type>(std::move(data), std::move(labels_vector)));
                      }
                  },
-                                   labels_vector_variant);
+                                   labels.labels);
              }),
              "create a new data set from the provided data and labels and additional optional parameters",
              py::arg("X"),
              py::arg("y"),
              py::pos_only(),
              py::arg("scaler") = std::nullopt)
         .def("save", [](const classification_data_set_wrapper &self, const std::string &filename, const plssvm::file_format_type format) { std::visit([&filename, format](auto &&data) { data.save(filename, format); }, self.data_set); }, "save the data set to a file using the provided file format type", py::arg("filename"), py::pos_only(), py::arg("format") = plssvm::file_format_type::libsvm)
-        .def("data", [](const classification_data_set_wrapper &self) { return std::visit([](auto &&data) { return plssvm::bindings::python::util::matrix_to_pyarray(data.data()); }, self.data_set); }, "the data saved as 2D vector")
+        .def("data", [](const classification_data_set_wrapper &self) { return std::visit([](auto &&data) { return py::cast(data.data()); }, self.data_set); }, "the data saved as 2D vector")
         .def("has_labels", [](const classification_data_set_wrapper &self) { return std::visit([](auto &&data) { return data.has_labels(); }, self.data_set); }, "check whether the data set has labels")
         // clang-format off
         .def("labels", [](const classification_data_set_wrapper &self) {

bindings/Python/conversion_to_python.hpp

@@ -10,7 +10,7 @@
 
 #include "plssvm/constants.hpp"  // plssvm::real_type
 
-#include "bindings/Python/conversion_to_python.hpp"  // plssvm::bindings::python::util::vector_to_pyarray
+#include "bindings/Python/utility.hpp"  // plssvm::bindings::python::util::vector_to_pyarray
 
 #include "fmt/format.h"         // fmt::format
 #include "pybind11/numpy.h"     // py::array
@@ -54,7 +54,8 @@ void init_min_max_scaler(py::module_ &m) {
                      throw py::value_error{ fmt::format("MinMaxScaler can only be created from two interval values (lower, upper), but {} were provided!", interval.size()) };
                  }
                  return plssvm::min_max_scaler{ interval[0].cast<plssvm::real_type>(), interval[1].cast<plssvm::real_type>() };
-             }), "create new scaling factors for the range [lower, upper]")
+             }),
+             "create new scaling factors for the range [lower, upper]")
         .def("save", &plssvm::min_max_scaler::save, "save the scaling factors to a file")
         .def("scaling_interval", &plssvm::min_max_scaler::scaling_interval, "the interval to which the data points are scaled")
         .def(