pymodaq 4.4.6__py3-none-any.whl → 4.4.9__py3-none-any.whl

pymodaq/control_modules/daq_move.py

@@ -616,10 +616,12 @@ class DAQ_Move(ParameterControlModule):
         if ('°' in unit or 'degree' in unit) and not '°C' in unit:
             # special cas as pint base unit for angles are radians
             return '°'
-        elif 'W' in unit or 'watt' in unit:
+        elif 'W' in unit or 'watt' in unit.lower():
             return 'W'
         elif '°C' in unit or 'Celsius' in unit:
             return '°C'
+        elif 'V' in unit or 'volt' in unit.lower():
+            return 'V'
         else:
             return str(Q_(1, unit).to_base_units().units)
 
@@ -711,7 +713,8 @@ class DAQ_Move_Hardware(QObject):
             Uninitialize the stage closing the hardware.
 
         """
-        self.hardware.close()
+        if self.hardware is not None:
+            self.hardware.close()
 
         return "Stage uninitialized"
 

pymodaq/control_modules/daq_move_ui.py

@@ -15,7 +15,7 @@ from qtpy.QtWidgets import QHBoxLayout, QVBoxLayout, QGridLayout, QWidget, QTool
 
 from pymodaq.utils.daq_utils import ThreadCommand
 from pymodaq.utils.gui_utils.custom_app import CustomApp
-from pymodaq.utils.gui_utils.widgets import PushButtonIcon, LabelWithFont, SpinBox, QSpinBox_ro, QLED
+from pymodaq.utils.gui_utils.widgets import PushButtonIcon, LabelWithFont, SpinBox, QSpinBox_ro, QLED, QSpinBoxWithShortcut
 from pymodaq.control_modules.utils import ControlModuleUI
 from pymodaq.utils.gui_utils import DockArea
 from pymodaq.utils.plotting.data_viewers.viewer import ViewerDispatcher
@@ -199,9 +199,9 @@ class DAQ_Move_UI(ControlModuleUI):
         self.main_ui.layout().addWidget(self.toolbar, 0, 0, 1, 2)
         self.main_ui.layout().addWidget(self.move_toolbar, 1, 0, 1, 2)
 
-        self.abs_value_sb = SpinBox(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
+        self.abs_value_sb = QSpinBoxWithShortcut(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
         self.abs_value_sb.setStyleSheet("background-color : lightgreen; color: black")
-        self.abs_value_sb_2 = SpinBox(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
+        self.abs_value_sb_2 = QSpinBoxWithShortcut(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
         self.abs_value_sb_2.setStyleSheet("background-color : lightcoral; color: black")
         self.move_toolbar.addWidget(self.abs_value_sb)
         self.move_toolbar.addWidget(self.abs_value_sb_2)
@@ -227,7 +227,7 @@ class DAQ_Move_UI(ControlModuleUI):
         self.control_ui.layout().addWidget(LabelWithFont('Abs. Value'), 0, 0)
         self.find_home_pb = PushButtonIcon('home2', 'Find Home')
         self.control_ui.layout().addWidget(self.find_home_pb, 0, 1)
-        self.abs_value_sb_bis = SpinBox(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
+        self.abs_value_sb_bis = QSpinBoxWithShortcut(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
         self.control_ui.layout().addWidget(self.abs_value_sb_bis, 1, 0)
         self.move_abs_pb = PushButtonIcon('Move', 'Set Abs.',
                                           tip='Set the value of the actuator to the set absolute value')
@@ -236,7 +236,7 @@ class DAQ_Move_UI(ControlModuleUI):
         self.move_rel_plus_pb = PushButtonIcon('MoveUp', 'Set Rel. (+)')
         self.control_ui.layout().addWidget(self.move_rel_plus_pb, 2, 1)
 
-        self.rel_value_sb = SpinBox(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
+        self.rel_value_sb = QSpinBoxWithShortcut(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'), key_sequences=("Ctrl+Enter","Ctrl+Shift+Enter"),)
         self.control_ui.layout().addWidget(self.rel_value_sb, 3, 0)
         self.move_rel_minus_pb = PushButtonIcon('MoveDown', 'Set Rel. (-)')
         self.control_ui.layout().addWidget(self.move_rel_minus_pb, 3, 1)
@@ -302,9 +302,16 @@ class DAQ_Move_UI(ControlModuleUI):
         self.connect_action('show_config', lambda: self.command_sig.emit(ThreadCommand('show_config', )))
 
         self.move_abs_pb.clicked.connect(lambda: self.emit_move_abs(self.abs_value_sb_bis))
+        self.abs_value_sb.shortcut["Ctrl+Enter"].activated.connect(lambda: self.emit_move_abs(self.abs_value_sb))
+        self.abs_value_sb_2.shortcut["Ctrl+Enter"].activated.connect(lambda: self.emit_move_abs(self.abs_value_sb_2))
+        self.abs_value_sb_bis.shortcut["Ctrl+Enter"].activated.connect(lambda: self.emit_move_abs(self.abs_value_sb_bis))
 
         self.rel_value_sb.valueChanged.connect(lambda: self.command_sig.emit(
             ThreadCommand('rel_value', self.rel_value_sb.value())))
+        
+        self.rel_value_sb.shortcut["Ctrl+Enter"].activated.connect(lambda: self.emit_move_rel('+'))
+        self.rel_value_sb.shortcut["Ctrl+Shift+Enter"].activated.connect(lambda: self.emit_move_rel('-'))
+
         self.move_rel_plus_pb.clicked.connect(lambda: self.emit_move_rel('+'))
         self.move_rel_minus_pb.clicked.connect(lambda: self.emit_move_rel('-'))
 

pymodaq/control_modules/move_utility_classes.py

@@ -67,11 +67,11 @@ class DataActuatorType(BaseEnum):
 def comon_parameters(epsilon=config('actuator', 'epsilon_default'),
                      epsilons=None):
     if epsilons is not None:
-        epsilon=epsilons
+        epsilon = epsilons
     if isinstance(epsilon, list):
-        epsilon=epsilon[0]
+        epsilon = epsilon[0]
     elif isinstance(epsilon, dict):
-        epsilon=epsilon[list[epsilon.keys()][0]]
+        epsilon = epsilon[list[epsilon.keys()][0]]
 
     return [{'title': 'Units:', 'name': 'units', 'type': 'str', 'value': '', 'readonly': True},
             {'title': 'Epsilon:', 'name': 'epsilon', 'type': 'float',
@@ -124,7 +124,7 @@ def comon_parameters_fun(is_multiaxes=False, axes_names=None,
 
     Parameters
     ----------
-    is_multiaxes: bool  # deprecated not need anymore
+    is_multiaxes: bool
         If True, display the particular settings to define which axis the controller is driving
     axes_names: deprecated, use axis_names
     axis_names: list of str or dictionnary of string as key and integer as value
@@ -140,7 +140,7 @@ def comon_parameters_fun(is_multiaxes=False, axes_names=None,
             axes_names = ['']
         axis_names = axes_names
 
-    is_multiaxes = len(axis_names) > 1
+    is_multiaxes = len(axis_names) > 1 or is_multiaxes
     if isinstance(axis_names, list):
         if len(axis_names) > 0:
             axis_name = axis_names[0]
@@ -617,6 +617,10 @@ class DAQ_Move_base(QObject):
         else:
             raise NotImplementedError
 
+
+    def close(self):
+        raise NotImplementedError
+
     def move_abs(self, value: Union[float, DataActuator]):
         if hasattr(self, 'move_Abs'):
             deprecation_msg('move_Abs method in plugins is deprecated, use move_abs', 3)

pymodaq/control_modules/utils.py

@@ -358,7 +358,6 @@ class ParameterControlModule(ParameterManager, ControlModule):
     listener_class: Type[ActorListener] = ActorListener
 
     def __init__(self, **kwargs):
-        QObject.__init__(self)
         ParameterManager.__init__(self, action_list=('save', 'update'))
         ControlModule.__init__(self)
 

pymodaq/extensions/daq_scan.py

@@ -82,7 +82,12 @@ class DAQScan(QObject, ParameterManager):
             {'title': 'Timeout (ms)', 'name': 'timeout', 'type': 'int', 'value': 10000},
         ]},
         {'title': 'Scan options', 'name': 'scan_options', 'type': 'group', 'children': [
-            {'title': 'Naverage:', 'name': 'scan_average', 'type': 'int', 'value': 1, 'min': 1},
+            {'title': 'Naverage:', 'name': 'scan_average', 'type': 'int',
+             'value': config('scan', 'Naverage'), 'min': 1},
+            {'title': 'Plot on top:', 'name': 'average_on_top', 'type': 'bool',
+             'value': config('scan', 'average_on_top'),
+             'tip': 'At the second iteration will plot the averaged scan on top (True) of the current one'
+                    'or in a second panel (False)'},
         ]},
 
         {'title': 'Plotting options', 'name': 'plot_options', 'type': 'group', 'children': [
@@ -629,6 +634,10 @@ class DAQScan(QObject, ParameterManager):
             viewers_enum.extend([ViewersEnum('Data1D').increase_dim(self.scanner.n_axes)
                                  for _ in range(len(self.settings['plot_options', 'plot_1d']['selected']))])
             data_names.extend(self.settings['plot_options', 'plot_1d']['selected'][:])
+        if not self.settings['scan_options', 'average_on_top']:
+
+            viewers_enum = viewers_enum + viewers_enum
+            data_names = data_names + [f'{data_name}_averaged' for data_name in data_names]
         self.live_plotter.prepare_viewers(viewers_enum, viewers_name=data_names)
 
     def update_status(self, txt: str, wait_time=0):
@@ -668,6 +677,7 @@ class DAQScan(QObject, ParameterManager):
             self.ui.set_scan_step_average(status.attribute[1] + 1)
 
         elif status.command == "Scan_done":
+
             self.modules_manager.reset_signals()
             self.live_timer.stop()
             self.ui.set_scan_done()
@@ -732,6 +742,7 @@ class DAQScan(QObject, ParameterManager):
             self.live_plotter.load_plot_data(group_0D=self.settings['plot_options', 'group0D'],
                                              average_axis=average_axis,
                                              average_index=self.ind_average,
+                                             separate_average= not self.settings['scan_options', 'average_on_top'],
                                              target_at=self.scanner.positions[self.ind_scan],
                                              last_step=(self.ind_scan ==
                                                         self.scanner.positions.size - 1 and
@@ -765,6 +776,8 @@ class DAQScan(QObject, ParameterManager):
                 messagebox(text="There are not enough or too much selected move modules for this scan")
                 return False
 
+            ## TODO the stuff about adaptive scans have to be moved into a dedicated extension. M
+            ## Most similat to the Bayesian one!
             if self.scanner.scan_sub_type == 'Adaptive':
                 #todo include this in scanners objects for the adaptive scanners
                 if len(self.modules_manager.get_selected_probed_data('0D')) == 0:
@@ -852,9 +865,15 @@ class DAQScan(QObject, ParameterManager):
             self.save_metadata(scan_node, 'scan_info')
 
             self._init_live()
+            Naverage = self.settings['scan_options', 'scan_average']
+            if Naverage > 1:
+                scan_shape = [Naverage]
+                scan_shape.extend(self.scanner.get_scan_shape())
+            else:
+                scan_shape = self.scanner.get_scan_shape()
             for det in self.modules_manager.detectors:
                 det.module_and_data_saver = (
-                    module_saving.DetectorExtendedSaver(det, self.scanner.get_scan_shape()))
+                    module_saving.DetectorExtendedSaver(det, scan_shape))
             self.module_and_data_saver.h5saver = self.h5saver  # force the update as the h5saver ill also be set on each detectors
 
             # mandatory to deal with multithreads
@@ -1034,7 +1053,7 @@ class DAQScanAcquisition(QObject):
 
     def start_acquisition(self):
         try:
-            #todo hoaw to apply newlayout to adaptive mode?
+            #todo hoaw to apply newlayout to adaptive mode? => cannot has to be a new extension
 
             self.modules_manager.connect_actuators()
             self.modules_manager.connect_detectors()
@@ -1106,6 +1125,7 @@ class DAQScanAcquisition(QObject):
                     # daq_scan wait time
                     QThread.msleep(self.scan_settings.child('time_flow', 'wait_time').value())
 
+            self.modules_manager.timeout_signal.disconnect()
             self.modules_manager.connect_actuators(False)
             self.modules_manager.connect_detectors(False)
 
@@ -1113,6 +1133,7 @@ class DAQScanAcquisition(QObject):
                                                      attribute="Acquisition has finished"))
             self.status_sig.emit(utils.ThreadCommand("Scan_done"))
 
+
         except Exception as e:
             logger.exception(str(e))
 
@@ -1148,7 +1169,8 @@ class DAQScanAcquisition(QObject):
             full_names: list = self.scan_settings['plot_options', 'plot_0d']['selected'][:]
             full_names.extend(self.scan_settings['plot_options', 'plot_1d']['selected'][:])
             data_temp = det_done_datas.get_data_from_full_names(full_names, deepcopy=False)
-            data_temp = data_temp.get_data_with_naxes_lower_than(2-len(indexes))  # maximum Data2D included nav indexes
+            n_nav_axis_selection = 2-len(indexes) + 1 if self.Naverage > 1 else 2-len(indexes)
+            data_temp = data_temp.get_data_with_naxes_lower_than(n_nav_axis_selection)  # maximum Data2D included nav indexes
 
             self.scan_data_tmp.emit(ScanDataTemp(self.ind_scan, indexes, data_temp))
 

pymodaq/extensions/daq_scan_ui.py

@@ -114,7 +114,7 @@ class DAQScanUI(CustomApp, ViewerDispatcher):
 
         settings_widget = QtWidgets.QWidget()
         settings_widget.setLayout(QtWidgets.QVBoxLayout())
-        settings_widget.setMinimumWidth(220)
+        #settings_widget.setMinimumWidth(220)
 
         splitter_v_widget.addWidget(self.module_widget)
         splitter_v_widget.addWidget(self.plotting_widget)

pymodaq/extensions/pid/daq_move_PID.py

@@ -1,4 +1,4 @@
-from pymodaq_utils.utils import ThreadCommand
+from pymodaq.utils.daq_utils import ThreadCommand
 
 from pymodaq.control_modules.move_utility_classes import (DAQ_Move_base, comon_parameters_fun,
                                                           DataActuatorType, DataActuator)

pymodaq/post_treatment/load_and_plot.py

@@ -67,7 +67,7 @@ class LoaderPlotter:
     def load_data(self, filter_dims: List[Union[DataDim, str]] = None,
                   filter_full_names: List[str] = None, remove_navigation: bool = True,
                   group_0D=False, average_axis: int=None, average_index: int = 0,
-                  last_step=False):
+                  last_step=False, separate_average=False):
         """Load Data from the h5 node of the dataloader and apply some filtering/manipulation before
         plotting
 
@@ -89,6 +89,8 @@ class LoaderPlotter:
             which step in the averaging process are we in.
         last_step: bool
             tells if this is the very last step of the (averaged) scan
+        separate_average: bool
+            Tells if the averaged data are to be plotted on the same data viewer panel or another one
 
         Returns
         -------
@@ -99,7 +101,8 @@ class LoaderPlotter:
         self.dataloader.load_all('/', self._data)
 
         if average_axis is not None:
-            self.average_axis(average_axis, average_index, last_step=last_step)
+            self.average_axis(average_axis, average_index, last_step=last_step,
+                              separate_average=separate_average)
 
         if filter_dims is not None:
             filter_dims[:] = [enum_checker(DataDim, dim) for dim in filter_dims]
@@ -110,14 +113,15 @@ class LoaderPlotter:
                                   filter_full_names]
 
         if group_0D:  # 0D initial data
-            self.group_0D_data()
+            self.group_0D_data(separate_average=separate_average)
 
         if remove_navigation:
             self.remove_navigation_axes()
 
         return self._data
 
-    def average_axis(self, average_axis, average_index, last_step=False) -> None:
+    def average_axis(self, average_axis, average_index, last_step=False,
+                     separate_average=False) -> None:
         """ Average the data along their average axis
 
         Parameters
@@ -129,7 +133,12 @@ class LoaderPlotter:
             which step in the averaging process are we in.
         last_step: bool
             tells if this is the very last step of the (averaged) scan
+        separate_average: bool
+            Tells if the averaged data are to be plotted on the same data viewer panel or another one
+
         """
+        if separate_average and average_index > 0:
+            averaged_data = DataToExport('Averaged')
         for ind, data in enumerate(self._data):
             current_data = data.inav[average_index, ...]
             if average_index > 0:
@@ -140,10 +149,16 @@ class LoaderPlotter:
                         data_to_append = data.inav[0, ...]
                     else:
                         data_to_append = data.inav[0:average_index, ...].mean(axis=average_axis)
-
+                data_to_append.name = f'{data_to_append.name}_averaged'
                 data_to_append.labels = [f'{label}_averaged' for label in data_to_append.labels]
-                current_data.append(data_to_append)
+                if not (separate_average and average_index > 0):
+                    current_data.append(data_to_append)
+                else:
+                    averaged_data.append(data_to_append)
             self._data[ind] = current_data
+        if separate_average and average_index > 0:
+            self._data.append(averaged_data.data)
+
 
     def remove_navigation_axes(self):
         """Make the navigation axes as signal axes
@@ -156,18 +171,27 @@ class LoaderPlotter:
             data.transpose()  # because usual ND data should be plotted here as 2D with the nav axes as the minor
             # (horizontal)
 
-    def group_0D_data(self):
+    def group_0D_data(self, separate_average=False):
         """Group in a single DataFromPlugins all data that are initialy Data0D
 
         """
         data = self._data.get_data_from_sig_axes(0)
         if len(data) > 0:
             data0D_arrays = []
+            data0D_arrays_averaged = []
             labels = []
+            labels_averaged = []
             for dwa in data:
-                data0D_arrays.extend(dwa.data)
-                labels.extend([f'{dwa.get_full_name()}/{label}' for label in dwa.labels])
-                self._data.remove(dwa)
+                if 'averaged' in dwa.name and separate_average:
+                    data0D_arrays_averaged.extend(dwa.data)
+                    labels_averaged.extend([f'{dwa.get_full_name()}/{label}' for label in dwa.labels])
+                    self._data.remove(dwa)
+
+
+                else:
+                    data0D_arrays.extend(dwa.data)
+                    labels.extend([f'{dwa.get_full_name()}/{label}' for label in dwa.labels])
+                    self._data.remove(dwa)
 
             data0D = DataFromPlugins(self.grouped_data0D_fullname.split('/')[1],
                                      data=data0D_arrays, labels=labels,
@@ -176,6 +200,15 @@ class LoaderPlotter:
                                      axes=dwa.axes, nav_indexes=dwa.nav_indexes,
                                      )
             self._data.append(data0D)
+            if 'averaged' in dwa.name and separate_average:
+                data0D_averaged = DataFromPlugins(
+                    f"{self.grouped_data0D_fullname.split('/')[1]}_averaged",
+                    data=data0D_arrays_averaged, labels=labels_averaged,
+                    dim='DataND',
+                    origin=self.grouped_data0D_fullname.split('/')[0],
+                    axes=dwa.axes, nav_indexes=dwa.nav_indexes,
+                )
+                self._data.append(data0D_averaged)
 
     def load_plot_data(self, **kwargs):
         """Load and plot all data from the current H5Saver

pymodaq/resources/QtDesigner_Ressources/QtDesigner_ressources_rc.py

@@ -6,7 +6,7 @@
 #
 # WARNING! All changes made in this file will be lost!
 
-from PyQt5 import QtCore
+from qtpy import QtCore
 
 qt_resource_data = b"\
 \x00\x00\x07\xbc\

pymodaq/resources/VERSION

@@ -1,2 +1,2 @@
-version = '4.4.6'
+version = '4.4.9'
 

pymodaq/resources/config_template.toml

@@ -86,6 +86,7 @@ scan_in_thread = true
 show_popups = true
 default = "Scan2D"
 Naverage = 1  # minimum is 1
+average_on_top = true
 steps_limit = 1000  # the limit of the number of steps you can set in a given scan
 sort1D = true
 

pymodaq/utils/data.py

@@ -20,7 +20,6 @@ from time import time
 import copy
 import pint
 from multipledispatch import dispatch
-import pymodaq
 from pymodaq.utils.enums import BaseEnum, enum_checker
 from pymodaq.utils.messenger import deprecation_msg
 from pymodaq.utils.daq_utils import find_objects_in_list_from_attr_name_val
@@ -98,6 +97,7 @@ class DataUnitError(Exception):
 
 
 class DwaType(BaseEnum):
+    """Different types of `DataWithAxes`."""
     DataWithAxes = 0
     DataRaw = 1
     DataActuator = 2
@@ -156,6 +156,24 @@ class DataDistribution(BaseEnum):
     spread = 1
 
 
+def _compute_slices_from_axis(axis: Axis, _slice, *ignored, is_index=True, **ignored_also):
+    if not is_index:
+        if isinstance(_slice, numbers.Number):
+            if not is_index:
+                _slice = axis.find_index(_slice)
+        elif _slice is Ellipsis:
+            return _slice
+        elif isinstance(_slice, slice):
+            if not (_slice.start is None and
+                    _slice.stop is None and _slice.step is None):
+                start = axis.find_index(
+                    _slice.start if _slice.start is not None else axis.get_data()[0])
+                stop = axis.find_index(
+                    _slice.stop if _slice.stop is not None else axis.get_data()[-1])
+                _slice = slice(start, stop)
+    return _slice
+
+
 class Axis:
     """Object holding info and data about physical axis of some data
 
@@ -366,8 +384,9 @@ class Axis:
     def __len__(self):
         return self.size
 
-    def _compute_slices(self, slices, *ignored, **ignored_also):
-        return slices
+    def _compute_slices(self, _slice, *ignored, is_index=True, **ignored_also):
+        _slice = _compute_slices_from_axis(self, _slice, is_index=is_index)
+        return _slice, _slice
 
     def _slicer(self, _slice, *ignored, **ignored_also):
         ax: Axis = copy.deepcopy(self)
@@ -2187,11 +2206,22 @@ class DataWithAxes(DataBase):
                         axes.append(ax)
         self.axes = axes
 
-    def _compute_slices(self, slices, is_navigation=True):
+    def _compute_slices(self, slices, is_navigation=True, is_index=True):
         """Compute the total slice to apply to the data
 
         Filling in Ellipsis when no slicing should be done
+        Parameters
+        ----------
+        slices: List of slice
+        is_navigation: bool
+        is_index: bool
+            if False, the slice are on the values of the underlying axes
+        Returns
+        -------
+        list(slice): the computed slices as index (eventually for all axes)
+        list(slice): a version as index of the input argument
         """
+        _slices_as_index = []
         if isinstance(slices, numbers.Number) or isinstance(slices, slice):
             slices = [slices]
         if is_navigation:
@@ -2202,13 +2232,29 @@ class DataWithAxes(DataBase):
         slices = list(slices)
         for ind in range(len(self.shape)):
             if ind in indexes:
-                total_slices.append(slices.pop(0))
+                _slice = slices.pop(0)
+                if not is_index:
+                    axis = self.get_axis_from_index(ind)[0]
+                    _slice = _compute_slices_from_axis(axis, _slice, is_index=is_index)
+                _slices_as_index.append(_slice)
+                total_slices.append(_slice)
             elif len(total_slices) == 0:
                 total_slices.append(Ellipsis)
             elif not (Ellipsis in total_slices and total_slices[-1] is Ellipsis):
                 total_slices.append(slice(None))
+            if len(slices) == 0 and self.distribution == DataDistribution.uniform and is_navigation:
+                if total_slices[-1] is Ellipsis:
+                    for ind in range(len(total_slices), len(indexes)):
+                        _slices_as_index.append(slice(None))
+                else:
+                    for ind in range(len(total_slices), len(indexes)):
+                        _slices_as_index.insert(0, Ellipsis)
+                    for ind in range(len(indexes), len(self.shape)):
+                        total_slices.append(slice(None))
+
+                break
         total_slices = tuple(total_slices)
-        return total_slices
+        return total_slices, _slices_as_index
 
     def check_squeeze(self, total_slices: List[slice], is_navigation: bool):
 
@@ -2220,7 +2266,7 @@ class DataWithAxes(DataBase):
                 do_squeeze = False
         return do_squeeze
 
-    def _slicer(self, slices, is_navigation=True):
+    def _slicer(self, slices, is_navigation=True, is_index=True):
         """Apply a given slice to the data either navigation or signal dimension
 
         Parameters
@@ -2229,6 +2275,8 @@ class DataWithAxes(DataBase):
             the slices to apply to the data
         is_navigation: bool
             if True apply the slices to the navigation dimension else to the signal ones
+        is_index: bool
+            if True the slices are indexes otherwise the slices are axes values to be indexed first
 
         Returns
         -------
@@ -2236,10 +2284,10 @@ class DataWithAxes(DataBase):
             Object of the same type as the initial data, derived from DataWithAxes. But with lower
             data size due to the slicing and with eventually less axes.
         """
-
         if isinstance(slices, numbers.Number) or isinstance(slices, slice):
             slices = [slices]
-        total_slices = self._compute_slices(slices, is_navigation)
+
+        total_slices, slices = self._compute_slices(slices, is_navigation, is_index=is_index)
 
         do_squeeze = self.check_squeeze(total_slices, is_navigation)
         new_arrays_data = [squeeze(dat[total_slices], do_squeeze) for dat in self.data]
@@ -2289,11 +2337,11 @@ class DataWithAxes(DataBase):
         if len(nav_indexes) != 0:
             distribution = self.distribution
         else:
-            distribution = DataDistribution['uniform']
+            distribution = DataDistribution.uniform
 
         data = DataWithAxes(self.name, data=new_arrays_data, nav_indexes=tuple(nav_indexes),
                             axes=axes,
-                            source='calculated', origin=self.origin,
+                            source=DataSource.calculated, origin=self.origin,
                             labels=self.labels[:],
                             distribution=distribution)
         return data

pymodaq/utils/gui_utils/widgets/__init__.py

@@ -1,5 +1,5 @@
 from .qled import QLED
 from .push import PushButtonIcon, EditPush, EditPushRel
-from .spinbox import QSpinBox_ro, SpinBox
+from .spinbox import QSpinBox_ro, SpinBox, QSpinBoxWithShortcut
 from .table import TableView, TableModel
 from .label import LabelWithFont

pymodaq/utils/gui_utils/widgets/spinbox.py

@@ -1,4 +1,4 @@
-from qtpy import QtWidgets, QtGui
+from qtpy import QtWidgets, QtGui,QtCore
 from pyqtgraph.widgets.SpinBox import SpinBox
 
 
@@ -15,7 +15,20 @@ class SpinBox(SpinBox):
             self.setFont(font)
         self.setMinimumHeight(min_height)
 
-
+class QSpinBoxWithShortcut(SpinBox):
+    """
+    QSpinBox but which accepts key sequences and store them as attribute
+    For now, it does not apply to regular input such as text or numerics.
+    """
+    def __init__(self, *args, key_sequences=("Ctrl+Enter",), **kwargs):
+        super().__init__(*args, **kwargs)
+        
+        self.shortcut = dict() #Store shortcuts in a dictionnary
+        for key_sequence in key_sequences:
+            shortcut = QtWidgets.QShortcut(QtGui.QKeySequence(key_sequence), self)
+            shortcut.setContext(QtCore.Qt.ShortcutContext.WidgetWithChildrenShortcut)
+            self.shortcut[key_sequence] = shortcut
+        
 class QSpinBox_ro(SpinBox):
     def __init__(self, *args, readonly=True, **kwargs):
         super().__init__(*args, **kwargs)

pymodaq/utils/h5modules/data_saving.py

@@ -58,8 +58,12 @@ class DataManagement(metaclass=ABCMeta):
         self.close_file()
 
     def close_file(self):
+        self._h5saver.flush()
         self._h5saver.close_file()
 
+    def close(self):
+        self.close_file()
+
     def _get_next_node_name(self, where: Union[str, Node]) -> str:
         """Get the formatted next node name given the ones already saved
 
@@ -600,7 +604,7 @@ class DataEnlargeableSaver(DataSaverLoader):
                     self._axis_saver.add_axis(where, axis)
 
     def add_data(self, where: Union[Node, str], data: DataWithAxes,
-                 axis_values: Iterable[float] = None):
+                 axis_values: Iterable[float] = None, **kwargs):
         """ Append data to an enlargeable array node
 
         Data of dim (0, 1 or 2) will be just appended to the enlargeable array.
@@ -624,17 +628,31 @@ class DataEnlargeableSaver(DataSaverLoader):
         if self.get_last_node_name(where) is None:
             if len(data.nav_indexes) == 0:
                 data_init = data
+            elif len(data.nav_indexes) == 1:  # special case of DataND data
+                data_init = data.inav[0]
+                add_enl_axes = True
+                axis = data.get_axis_from_index(data.nav_indexes[0])[0]
+                axis_values = (axis.get_data(),)
+                self._enl_axis_names = (axis.label,)
+                self._enl_axis_units = (axis.units,)
             else:
                 raise DataDimError('It is not possible to append DataND')
             self._create_data_arrays(where, data_init, save_axes=True, add_enl_axes=add_enl_axes)
+        elif len(data.nav_indexes) == 1:  # special case of DataND data
+            add_enl_axes = True
+            axis = data.get_axis_from_index(data.nav_indexes[0])[0]
+            axis_values = (axis.get_data(),)
 
         for ind_data in range(len(data)):
             array: EARRAY = self.get_node_from_index(where, ind_data)
             array.append(data[ind_data])
-        if add_enl_axes and axis_values is not None:
+        if add_enl_axes:
             for ind_axis in range(self._n_enl_axes):
                 axis_array: EARRAY = self._axis_saver.get_node_from_index(where, ind_axis)
-                axis_array.append(np.array([axis_values[ind_axis]]))
+                if not isinstance(axis_values[ind_axis], np.ndarray):
+                    axis_array.append(np.array([axis_values[ind_axis]]))
+                else:
+                    axis_array.append(axis_values[ind_axis], expand=False)
                 axis_array.attrs['size'] += 1
 
 
@@ -862,7 +880,7 @@ class DataToExportEnlargeableSaver(DataToExportSaver):
     def add_data(self, where: Union[Node, str], data: DataToExport,
                  axis_values: List[Union[float, np.ndarray]] = None,
                  axis_value: Union[float, np.ndarray] = None,
-                 settings_as_xml='', metadata=None,
+                 settings_as_xml='', metadata=None, **kwargs
                  ):
         """
 
@@ -885,7 +903,7 @@ class DataToExportEnlargeableSaver(DataToExportSaver):
         if axis_values is None and axis_value is not None:
             axis_values = [axis_value]
 
-        super().add_data(where, data, settings_as_xml, metadata)
+        super().add_data(where, data, settings_as_xml, metadata, **kwargs)
         # a parent navigation group (same for all data nodes)
 
         where = self._get_node(where)