Fixed broken import in typecaster.h (#1181)

- Fixed the broken import _slsdet --> slsdet._slsdet caused by a previous upgrade
- Added tests that exercises the conversion from python to C++ and from C++ to python
- Python unit tests now run in CI (!)

python/src/duration.cpp

@@ -1,3 +1,4 @@
+#include <chrono>
 #include "py_headers.h"
 
 #include "DurationWrapper.h"
@@ -19,4 +20,25 @@ void init_duration(py::module &m) {
                << " count: " << self.count() << ")";
             return ss.str();
         });
+
+    m.def(
+        "test_return_DurationWrapper",
+        []() {
+            DurationWrapper t(1.3);
+            return t;
+        },
+        R"(
+          Test function to return a DurationWrapper object. Ensures that the automatic conversion in typecaster.h works.
+          )");
+
+    m.def(
+        "test_duration_to_ns",
+        [](const std::chrono::nanoseconds t) {
+            //Duration wrapper is used to be able to convert from time in python to chrono::nanoseconds
+            //return count to have something to test 
+            return t.count();
+        },
+        R"(
+          Test function convert DurationWrapper or number to chrono::ns. Ensures that the automatic conversion in typecaster.h works.
+          )"); // default value to test the default constructor
 }

python/src/typecaster.h

@@ -54,11 +54,16 @@ template <> struct type_caster<std::chrono::nanoseconds> {
                 value = duration_cast<nanoseconds>(duration<double>(PyFloat_AsDouble(src.ptr())));
                 return true;
             }
+            // If invoked with an int we assume it is nanoseconds and convert, same as in chrono.h
+            if (PyLong_Check(src.ptr())) {
+                value = duration_cast<nanoseconds>(duration<int64_t>(PyLong_AsLongLong(src.ptr())));
+                return true;
+            }
 
 
             // Lastly if we were actually called with a DurationWrapper object we get
             // the number of nanoseconds and create a std::chrono::nanoseconds from it
-            py::object py_cls = py::module::import("_slsdet").attr("DurationWrapper");
+            py::object py_cls = py::module::import("slsdet._slsdet").attr("DurationWrapper");
             if (py::isinstance(src, py_cls)){
                 sls::DurationWrapper *cls = src.cast<sls::DurationWrapper *>();
                 value = nanoseconds(cls->count());
@@ -77,7 +82,7 @@ template <> struct type_caster<std::chrono::nanoseconds> {
          * set the count from chrono::nanoseconds and return
          */
         static handle cast(std::chrono::nanoseconds src, return_value_policy /* policy */, handle /* parent */) {
-            py::object py_cls = py::module::import("_slsdet").attr("DurationWrapper");
+            py::object py_cls = py::module::import("slsdet._slsdet").attr("DurationWrapper");
             py::object* obj = new py::object;
             *obj = py_cls();
             sls::DurationWrapper *dur = obj->cast<sls::DurationWrapper *>();