From b3584032709083c1a93aa1f7483360d069c625ab Mon Sep 17 00:00:00 2001
From: Joey Kleingers <joey.kleingers@bluequartz.net>
Date: Sat, 23 Nov 2024 17:14:43 -0500
Subject: [PATCH] PYTHON: Expose methods to convert numeric types. (#1133)

- Expose method to convert numpy types to NumericType.
- Expose method to convert DataType to NumericType.

---------

Signed-off-by: Joey Kleingers <joey.kleingers@bluequartz.net>
---
 .../SimplnxCore/wrapping/python/simplnxpy.cpp | 83 ++++++++++++++++---
 1 file changed, 72 insertions(+), 11 deletions(-)

diff --git a/src/Plugins/SimplnxCore/wrapping/python/simplnxpy.cpp b/src/Plugins/SimplnxCore/wrapping/python/simplnxpy.cpp
index 65ec0eb33d..d977dc8c12 100644
--- a/src/Plugins/SimplnxCore/wrapping/python/simplnxpy.cpp
+++ b/src/Plugins/SimplnxCore/wrapping/python/simplnxpy.cpp
@@ -121,6 +121,17 @@ struct fmt::formatter<nx::core::Warning>
   }
 };
 
+/**
+ * @brief Equivalent to lhs.__eq__(rhs) in python
+ * @param lhs
+ * @param rhs
+ * @return bool
+ */
+bool PyIsEqual(py::handle lhs, py::handle rhs)
+{
+  return (lhs.attr("__eq__")(rhs)).cast<bool>();
+}
+
 template <class ParameterT>
 void PyInsertLinkableParameter(Parameters& self, const ParameterT& param)
 {
@@ -456,47 +467,47 @@ PYBIND11_MODULE(simplnx, mod)
   mod.def(
       "convert_np_dtype_to_datatype",
       [](const py::dtype& dtype) {
-        if((dtype.attr("__eq__")(py::dtype::of<int8>())).cast<bool>())
+        if(PyIsEqual(dtype, py::dtype::of<int8>()))
         {
           return DataType::int8;
         }
-        if((dtype.attr("__eq__")(py::dtype::of<uint8>())).cast<bool>())
+        if(PyIsEqual(dtype, py::dtype::of<uint8>()))
         {
           return DataType::uint8;
         }
-        if((dtype.attr("__eq__")(py::dtype::of<int16>())).cast<bool>())
+        if(PyIsEqual(dtype, py::dtype::of<int16>()))
         {
           return DataType::int16;
         }
-        if((dtype.attr("__eq__")(py::dtype::of<uint16>())).cast<bool>())
+        if(PyIsEqual(dtype, py::dtype::of<uint16>()))
         {
           return DataType::uint16;
         }
-        if((dtype.attr("__eq__")(py::dtype::of<int32>())).cast<bool>())
+        if(PyIsEqual(dtype, py::dtype::of<int32>()))
         {
           return DataType::int32;
         }
-        if((dtype.attr("__eq__")(py::dtype::of<uint32>())).cast<bool>())
+        if(PyIsEqual(dtype, py::dtype::of<uint32>()))
         {
           return DataType::uint32;
         }
-        if((dtype.attr("__eq__")(py::dtype::of<int64>())).cast<bool>())
+        if(PyIsEqual(dtype, py::dtype::of<int64>()))
         {
           return DataType::int64;
         }
-        if((dtype.attr("__eq__")(py::dtype::of<uint64>())).cast<bool>())
+        if(PyIsEqual(dtype, py::dtype::of<uint64>()))
         {
           return DataType::uint64;
         }
-        if((dtype.attr("__eq__")(py::dtype::of<float32>())).cast<bool>())
+        if(PyIsEqual(dtype, py::dtype::of<float32>()))
         {
           return DataType::float32;
         }
-        if((dtype.attr("__eq__")(py::dtype::of<float64>())).cast<bool>())
+        if(PyIsEqual(dtype, py::dtype::of<float64>()))
         {
           return DataType::float64;
         }
-        if((dtype.attr("__eq__")(py::dtype::of<bool>())).cast<bool>())
+        if(PyIsEqual(dtype, py::dtype::of<bool>()))
         {
           return DataType::boolean;
         }
@@ -506,6 +517,55 @@ PYBIND11_MODULE(simplnx, mod)
       },
       "Convert numpy dtype to simplnx DataType", "dtype"_a);
 
+  mod.def(
+      "convert_np_dtype_to_numeric_type",
+      [](const py::dtype& dtype) {
+        if(PyIsEqual(dtype, py::dtype::of<int8>()))
+        {
+          return NumericType::int8;
+        }
+        if(PyIsEqual(dtype, py::dtype::of<uint8>()))
+        {
+          return NumericType::uint8;
+        }
+        if(PyIsEqual(dtype, py::dtype::of<int16>()))
+        {
+          return NumericType::int16;
+        }
+        if(PyIsEqual(dtype, py::dtype::of<uint16>()))
+        {
+          return NumericType::uint16;
+        }
+        if(PyIsEqual(dtype, py::dtype::of<int32>()))
+        {
+          return NumericType::int32;
+        }
+        if(PyIsEqual(dtype, py::dtype::of<uint32>()))
+        {
+          return NumericType::uint32;
+        }
+        if(PyIsEqual(dtype, py::dtype::of<int64>()))
+        {
+          return NumericType::int64;
+        }
+        if(PyIsEqual(dtype, py::dtype::of<uint64>()))
+        {
+          return NumericType::uint64;
+        }
+        if(PyIsEqual(dtype, py::dtype::of<float32>()))
+        {
+          return NumericType::float32;
+        }
+        if(PyIsEqual(dtype, py::dtype::of<float64>()))
+        {
+          return NumericType::float64;
+        }
+
+        std::string dtypeStr = py::str(static_cast<py::object>(dtype));
+        throw std::invalid_argument(fmt::format("Unable to convert dtype to NumericType: Unsupported dtype '{}'.", dtypeStr));
+      },
+      "Convert numpy dtype to simplnx NumericType", "dtype"_a);
+
   py::enum_<ArrayHandlingType> arrayHandlingType(mod, "ArrayHandlingType");
   arrayHandlingType.value("Copy", ArrayHandlingType::Copy);
   arrayHandlingType.value("Move", ArrayHandlingType::Move);
@@ -1530,6 +1590,7 @@ PYBIND11_MODULE(simplnx, mod)
   mod.def("get_all_data_types", &GetAllDataTypes);
 
   mod.def("convert_numeric_type_to_data_type", &ConvertNumericTypeToDataType);
+  mod.def("convert_data_type_to_numeric_type", &ConvertDataTypeToNumericType);
 
   mod.def("get_filters", [corePlugin]() {
     auto filterHandles = corePlugin->getFilterHandles();