Merge branch 'developer' into dev/define_cmd

python/slsdet/detector.py

@@ -25,6 +25,7 @@ import datetime as dt
 
 from functools import wraps
 from collections import namedtuple
+from collections.abc import Sequence
 import socket
 import numpy as np
 
@@ -302,6 +303,46 @@ class Detector(CppDetectorApi):
     def rx_arping(self, value):
         ut.set_using_dict(self.setRxArping, value)
 
+    @property
+    def rx_roi(self): 
+        """Gets the list of ROIs configured in the receiver. 
+
+        Note
+        -----
+        Each ROI is represented as a tuple of (x_start, y_start, x_end, y_end). \n
+        If no ROIs are configured, returns [[-1,-1,-1,-1]].
+        """
+        return self.getRxROI() #vector of Roi structs how represented? 
+    
+    @rx_roi.setter
+    def rx_roi(self, rois):
+        """
+        Sets the list of ROIs in the receiver.
+        Can only set multiple ROIs at multi module level without gap pixels. If more than 1 ROI per
+        UDP port, it will throw. Setting number of udp interfaces will clear the
+        roi. Cannot be set for CTB or Xilinx CTB.  
+
+        Note
+        -----
+        Each ROI should be represented as a sequence of 4 ints (x_start, y_start, x_end, y_end). \n
+        For mythen3 or gotthard2 pass a sequence of 2 ints (x_start, x_end) \n
+        For multiple ROI's pass a sequence of sequence \n
+        Example: [[0, 100, 50, 100], [260, 270, 50,100]] \n
+        """
+        # TODO: maybe better to accept py::object in setRxROI and handle there? 
+        if not isinstance(rois, Sequence):
+            raise TypeError(
+            "setRxROI failed: expected a tuple/list of ints x_min, x_max, y_min, y_max "
+            "or a sequence of such."
+        )
+        if(not isinstance(rois[0], Sequence)): 
+            self.setRxROI([rois])
+        else:
+            self.setRxROI(rois)
+
+    def rx_clearroi(self): 
+        """Clears all the ROIs configured in the receiver."""
+        self.clearRxROI()
 
     @property
     @element

python/src/detector.cpp

@@ -946,6 +946,7 @@ void init_det(py::module &m) {
                        (void (Detector::*)(const std::vector<defs::ROI> &)) &
                            Detector::setRxROI,
                        py::arg());
+
     CppDetectorApi.def("clearRxROI",
                        (void (Detector::*)()) & Detector::clearRxROI);
     CppDetectorApi.def(

python/src/typecaster.h

@@ -1,11 +1,12 @@
 // SPDX-License-Identifier: LGPL-3.0-or-other
 // Copyright (C) 2021 Contributors to the SLS Detector Package
 #pragma once
-#include <pybind11/pybind11.h>
 #include <datetime.h>
+#include <pybind11/pybind11.h>
 
-#include "sls/Result.h"
 #include "DurationWrapper.h"
+#include "sls/Result.h"
+#include "sls/sls_detector_defs.h"
 
 namespace py = pybind11;
 namespace pybind11 {
@@ -14,84 +15,130 @@ template <typename Type, typename Alloc>
 struct type_caster<sls::Result<Type, Alloc>>
     : list_caster<sls::Result<Type, Alloc>, Type> {};
 
-
 // Based on the typecaster in pybind11/chrono.h
 template <> struct type_caster<std::chrono::nanoseconds> {
-    public:
-        PYBIND11_TYPE_CASTER(std::chrono::nanoseconds, const_name("DurationWrapper"));
+  public:
+    PYBIND11_TYPE_CASTER(std::chrono::nanoseconds,
+                         const_name("DurationWrapper"));
 
-        // signed 25 bits required by the standard.
-        using days = std::chrono::duration<int_least32_t, std::ratio<86400>>;
+    // signed 25 bits required by the standard.
+    using days = std::chrono::duration<int_least32_t, std::ratio<86400>>;
 
-        /**
-         * Conversion part 1 (Python->C++): convert a PyObject into std::chrono::nanoseconds
-         * try datetime.timedelta, floats and our DurationWrapper wrapper
-         */
+    /**
+     * Conversion part 1 (Python->C++): convert a PyObject into
+     * std::chrono::nanoseconds try datetime.timedelta, floats and our
+     * DurationWrapper wrapper
+     */
 
-        bool load(handle src, bool) {
-            using namespace std::chrono;
+    bool load(handle src, bool) {
+        using namespace std::chrono;
 
-            // Lazy initialise the PyDateTime import
-            if (!PyDateTimeAPI) {
-                PyDateTime_IMPORT;
-            }
+        // Lazy initialise the PyDateTime import
+        if (!PyDateTimeAPI) {
+            PyDateTime_IMPORT;
+        }
 
-            if (!src) {
+        if (!src) {
+            return false;
+        }
+        // If invoked with datetime.delta object, same as in chrono.h
+        if (PyDelta_Check(src.ptr())) {
+            value = duration_cast<nanoseconds>(
+                days(PyDateTime_DELTA_GET_DAYS(src.ptr())) +
+                seconds(PyDateTime_DELTA_GET_SECONDS(src.ptr())) +
+                microseconds(PyDateTime_DELTA_GET_MICROSECONDS(src.ptr()))
+
+            );
+            return true;
+        }
+        // If invoked with a float we assume it is seconds and convert, same as
+        // in chrono.h
+        if (PyFloat_Check(src.ptr())) {
+            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._slsdet").attr("DurationWrapper");
+        if (py::isinstance(src, py_cls)) {
+            sls::DurationWrapper *cls = src.cast<sls::DurationWrapper *>();
+            value = nanoseconds(cls->count());
+            return true;
+        }
+
+        return false;
+    }
+
+    /**
+     * Conversion part 2 (C++ -> Python)
+     * import the module to get a handle to the wrapped class
+     * Default construct an object of (wrapped) DurationWrapper
+     * 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._slsdet").attr("DurationWrapper");
+        py::object *obj = new py::object;
+        *obj = py_cls();
+        sls::DurationWrapper *dur = obj->cast<sls::DurationWrapper *>();
+        dur->set_count(src.count());
+        return *obj;
+    }
+};
+
+// Type caster for sls::defs::ROI from tuple
+template <> struct type_caster<sls::defs::ROI> {
+    PYBIND11_TYPE_CASTER(sls::defs::ROI, _("Sequence[int, int, int, int] or "
+                                           "Sequence[int, int]"));
+
+    // convert c++ ROI to python tuple
+    static handle cast(const sls::defs::ROI &roi, return_value_policy, handle) {
+        return py::make_tuple(roi.xmin, roi.xmax, roi.ymin, roi.ymax).release();
+    }
+
+    // convert from python to c++ ROI
+    bool load(handle roi, bool /*allow implicit conversion*/) {
+
+        // accept tuple, list, numpy array any sequence
+        py::sequence seq;
+        try {
+            seq = py::reinterpret_borrow<py::sequence>(roi);
+        } catch (...) {
+            return false;
+        }
+
+        if (seq.size() != 4 && seq.size() != 2)
+            return false;
+        // Check if each element is an int
+        for (auto item : seq) {
+            if (!py::isinstance<py::int_>(item)) {
                 return false;
             }
-            // If invoked with datetime.delta object, same as in chrono.h
-            if (PyDelta_Check(src.ptr())) {
-                value = duration_cast<nanoseconds>(
-                    days(PyDateTime_DELTA_GET_DAYS(src.ptr())) +
-                    seconds(PyDateTime_DELTA_GET_SECONDS(src.ptr())) +
-                    microseconds(PyDateTime_DELTA_GET_MICROSECONDS(src.ptr()))
-                    
-                );
-                return true;
-            }
-            // If invoked with a float we assume it is seconds and convert, same as in chrono.h
-            if (PyFloat_Check(src.ptr())) {
-                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._slsdet").attr("DurationWrapper");
-            if (py::isinstance(src, py_cls)){
-                sls::DurationWrapper *cls = src.cast<sls::DurationWrapper *>();
-                value = nanoseconds(cls->count());
-                return true;
-            }
-            
-            
-            return false;
-
         }
 
-        /**
-         * Conversion part 2 (C++ -> Python)
-         * import the module to get a handle to the wrapped class
-         * Default construct an object of (wrapped) DurationWrapper
-         * 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._slsdet").attr("DurationWrapper");
-            py::object* obj = new py::object;
-            *obj = py_cls();
-            sls::DurationWrapper *dur = obj->cast<sls::DurationWrapper *>();
-            dur->set_count(src.count());
-            return *obj;
+        value.xmin = seq[0].cast<int>();
+        value.xmax = seq[1].cast<int>();
+
+        if (seq.size() == 4) {
+            value.ymin = seq[2].cast<int>();
+            value.ymax = seq[3].cast<int>();
         }
-    };
-
 
+        return true;
+    }
+};
 
 } // namespace detail
 } // namespace pybind11

python/tests/conftest.py

@@ -0,0 +1,85 @@
+import pytest
+import sys
+import traceback
+
+from pathlib import Path
+
+current_dir = Path(__file__).resolve().parents[2]
+
+scripts_dir = current_dir / "tests" / "scripts"
+
+sys.path.append(str(scripts_dir))
+
+print(sys.path)
+
+from utils_for_test import (
+    Log,
+    LogLevel,
+    cleanup,
+    startReceiver,
+    startDetectorVirtualServer,
+    loadConfig, 
+    loadBasicSettings,
+)
+
+def pytest_addoption(parser):
+    parser.addoption(
+        "--with-detector-simulators", action="store_true", default=False, help="Run tests that require detector simulators"
+    )
+
+def pytest_configure(config):
+    config.addinivalue_line("markers", "withdetectorsimulators: mark test as needing detector simulators to run")
+
+def pytest_collection_modifyitems(config, items):
+    if config.getoption("--with-detector-simulators"):
+        return
+    skip = pytest.mark.skip(reason="need --with-detector-simulators option to run")
+    for item in items:
+        if "withdetectorsimulators" in item.keywords:
+            item.add_marker(skip)
+
+#helper fixture for servers
+@pytest.fixture
+def servers(request):
+    try:
+        return request.param  # comes from @pytest.mark.parametrize(..., indirect=True)
+    except AttributeError:
+        # fallback default if the test did not parametrize
+        return ['eiger', 'jungfrau', 'mythen3', 'gotthard2', 'ctb', 'moench', 'xilinx_ctb']
+    return request.param
+
+@pytest.fixture
+def test_with_simulators(servers):
+    """ Fixture to automatically setup virtual detector servers for testing. """
+
+    LOG_PREFIX_FNAME = '/tmp/slsDetectorPackage_virtual_PythonAPI_test'
+    MAIN_LOG_FNAME = LOG_PREFIX_FNAME + '_log.txt'
+
+    with open(MAIN_LOG_FNAME, 'w') as fp:
+        try:
+            nmods = 2
+            for server in servers:
+                for ninterfaces in range(1,2):
+                    if ninterfaces == 2 and server != 'jungfrau' and server != 'moench':
+                        continue
+                        
+                    msg = f'Starting Python API Tests for {server}'
+
+                    if server == 'jungfrau' or server == 'moench':
+                        msg += f' with {ninterfaces} interfaces'
+
+                    Log(LogLevel.INFOBLUE, msg, fp)
+                    cleanup(fp)
+                    startDetectorVirtualServer(server, nmods, fp)
+                    startReceiver(nmods, fp)
+                    d = loadConfig(name=server, log_file_fp=fp, num_mods=nmods, num_frames=1, num_interfaces=ninterfaces)
+                    loadBasicSettings(name=server, d=d, fp=fp)
+                    yield # run test 
+            cleanup(fp) # teardown 
+        except Exception as e:
+            with open(MAIN_LOG_FNAME, 'a') as fp_error:
+                traceback.print_exc(file=fp_error)
+                Log(LogLevel.ERROR, f'Tests Failed.', fp)
+            cleanup(fp)
+            
+

python/tests/test_pythonAPI.py

@@ -0,0 +1,48 @@
+import pytest 
+import sys 
+
+from conftest import test_with_simulators
+
+from slsdet import Detector
+
+@pytest.mark.withdetectorsimulators
+@pytest.mark.parametrize("servers", [["moench"]], indirect=True)
+def test_rx_ROI_moench(test_with_simulators, servers):
+    """ Test setting and getting rx_ROI property of Detector class for moench. """
+
+    d = Detector()
+    d.rx_roi = (0, 10, 10, 20)
+    roi = d.rx_roi
+    assert roi == [(0, 10, 10, 20)]
+    
+    d.rx_roi = [5,15,15,25]
+
+    assert d.rx_roi == [(5,15,15,25)]
+
+    d.rx_roi = [[0,10,0,20], [5,20,410,420]] 
+
+    roi = d.rx_roi
+    assert roi == [(0,10,0,20), (5,20,410,420)]
+
+    d.rx_clearroi() 
+    roi = d.rx_roi
+    assert roi == [(-1,-1,-1,-1)] 
+
+@pytest.mark.withdetectorsimulators
+@pytest.mark.parametrize("servers", [["mythen3"]], indirect=True)
+def test_rx_ROI_mythen(test_with_simulators, servers):
+    """ Test setting and getting rx_ROI property of Detector class for mythen. """
+
+    d = Detector()
+    d.rx_roi = (0, 10)
+    roi = d.rx_roi
+    assert roi == [(0, 10, -1, -1)]
+
+    #d.rx_roi = [[5,15, 0, 1]] # not allowed for mythen3
+
+    d.rx_roi = [0,10, -1, -1]
+
+    assert d.rx_roi == [(0,10,-1,-1)]
+    
+
+