pymodaq 5.0.1__tar.gz → 5.0.3__tar.gz

{pymodaq-5.0.1 → pymodaq-5.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pymodaq
-Version: 5.0.1
+Version: 5.0.3
 Summary: Modular Data Acquisition with Python
 Project-URL: Homepage, http://pymodaq.cnrs.fr
 Project-URL: Source, https://github.com/PyMoDAQ/PyMoDAQ
@@ -50,11 +50,11 @@ Requires-Dist: numpy<2.0.0
 Requires-Dist: packaging
 Requires-Dist: pint
 Requires-Dist: pyleco>0.3; python_version >= '3.8'
-Requires-Dist: pymodaq-data>=5.0.15
-Requires-Dist: pymodaq-gui>=5.0.16
+Requires-Dist: pymodaq-data>=5.0.18
+Requires-Dist: pymodaq-gui>=5.0.17
 Requires-Dist: pymodaq-plugin-manager>=0.0.17
 Requires-Dist: pymodaq-plugins-mock>=5.0.5
-Requires-Dist: pymodaq-utils
+Requires-Dist: pymodaq-utils>=0.0.14
 Requires-Dist: pyqtgraph>=0.12
 Requires-Dist: python-dateutil
 Requires-Dist: qtconsole

{pymodaq-5.0.1 → pymodaq-5.0.3}/pyproject.toml

@@ -31,9 +31,9 @@ classifiers = [
     "Topic :: Software Development :: User Interfaces",
 ]
 dependencies = [
-    "pymodaq_utils",
-    "pymodaq_gui>=5.0.16",
-    "pymodaq_data>=5.0.15",
+    "pymodaq_utils>=0.0.14",
+    "pymodaq_gui>=5.0.17",
+    "pymodaq_data>=5.0.18",
     "easydict",
     "multipledispatch",
     "numpy < 2.0.0",

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/control_modules/daq_move.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import numbers
 from importlib import import_module
 from numbers import Number
-from random import randint
+
 import sys
 from typing import List, Tuple, Union, Optional, Type
 import numpy as np
@@ -472,16 +472,7 @@ class DAQ_Move(ParameterControlModule):
             self.init_signal.emit(self._initialized_state)
 
         elif status.command == "get_actuator_value" or status.command == 'check_position':
-            if isinstance(status.attribute, DataActuator):
-                data_act: DataActuator = status.attribute
-            else:
-                data_act: DataActuator = status.attribute[0]  # backcompatibility
-            data_act.name = self.title  # for the DataActuator name to be the title of the DAQ_Move
-            if (not Unit(self.units).is_compatible_with(Unit(data_act.units)) and
-                    data_act.units == ''):  #this happens if the units have not been specified in
-                # the plugin
-                data_act.force_units(self.units)
-
+            data_act = self._check_data_type(status.attribute)
             if self.ui is not None:
                 self.ui.display_value(data_act)
                 if self.ui.is_action_checked('show_graph'):
@@ -495,11 +486,7 @@ class DAQ_Move(ParameterControlModule):
                 self._command_tcpip.emit(ThreadCommand(LECOMoveCommands.POSITION, data_act))
 
         elif status.command == "move_done":
-            if isinstance(status.attribute, DataActuator):
-                data_act: DataActuator = status.attribute
-            else:
-                data_act: DataActuator = status.attribute[0]  # deprecated
-            data_act.name = self.title  # for the DataActuator name to be the title of the DAQ_Move
+            data_act = self._check_data_type(status.attribute)
             if self.ui is not None:
                 self.ui.display_value(data_act)
                 self.ui.move_done = True
@@ -524,6 +511,22 @@ class DAQ_Move(ParameterControlModule):
         elif status.command == 'units':
             self.units = status.attribute
 
+    def _check_data_type(self, data_act: Union[list[np.ndarray], float, DataActuator]) -> DataActuator:
+        """ Make sure the data is a DataActuator
+
+        Mostly to make sure DAQ_Move is backcompatible with old style plugins
+        """
+        if isinstance(data_act, list):  # backcompatibility
+            data_act = data_act[0]
+        if isinstance(data_act, np.ndarray):  # backcompatibility
+            data_act = DataActuator(data=[data_act], units=self.units)
+        data_act.name = self.title  # for the DataActuator name to be the title of the DAQ_Move
+        if (not Unit(self.units).is_compatible_with(Unit(data_act.units)) and
+                data_act.units == ''):  #this happens if the units have not been specified in
+            # the plugin
+            data_act.force_units(self.units)
+        return  data_act
+
     def get_actuator_value(self):
         """Get the current actuator value via the "get_actuator_value" command send to the hardware
 

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/control_modules/daq_viewer.py

@@ -6,8 +6,10 @@ Created on Wed Jan 10 16:54:14 2018
 """
 from __future__ import annotations
 from importlib import import_module
+
 from collections import OrderedDict
 import copy
+
 import os
 from pathlib import Path
 from random import randint

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/control_modules/move_utility_classes.py

@@ -536,8 +536,8 @@ class DAQ_Move_base(QObject):
             return self._current_value
 
     @current_value.setter
-    def current_value(self, value: Union[float, DataActuator]):
-        if isinstance(value, numbers.Number):
+    def current_value(self, value: Union[float, np.ndarray, DataActuator]):
+        if isinstance(value, numbers.Number) or isinstance(value, np.ndarray):
             self._current_value = DataActuator(self._title, data=value,
                                                units=self.axis_unit)
         else:

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/dashboard.py

@@ -45,7 +45,7 @@ from pymodaq.utils import config as config_mod_pymodaq
 
 from pymodaq.control_modules.daq_move import DAQ_Move
 from pymodaq.control_modules.daq_viewer import DAQ_Viewer
-from pymodaq.utils.gui_utils import get_splash_sc
+from pymodaq_gui.utils.splash import get_splash_sc
 
 from pymodaq import extensions as extmod
 
@@ -395,11 +395,11 @@ class DashBoard(CustomApp):
         self.add_action('modify_preset', 'Modify Preset', '',
                         'Modify an existing experimental setup configuration file: a "preset"',
                         auto_toolbar=False)
-        self.add_action('load_preset', 'LOAD', 'Open',
-                        tip='Load the selected Preset: ')
+
         self.add_widget('preset_list', QtWidgets.QComboBox, toolbar=self.toolbar,
                         signal_str='currentTextChanged', slot=self.update_preset_action)
-
+        self.add_action('load_preset', 'LOAD', 'Open',
+                        tip='Load the selected Preset: ')
         self.update_preset_action_list()
 
         self.add_action('new_overshoot', 'New Overshoot', '',

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/extensions/daq_scan.py

@@ -86,7 +86,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': [
@@ -439,7 +444,7 @@ class DAQScan(QObject, ParameterManager):
         if not os.path.isdir(self.h5saver.settings['base_path']):
             os.mkdir(self.h5saver.settings['base_path'])
         filename = gutils.file_io.select_file(self.h5saver.settings['base_path'], save=True, ext='h5')
-        self.h5saver.h5_file.copy_file(str(filename))
+        self.h5saver.h5_file.copy_file(str(filename), overwrite=True)
 
     def save_metadata(self, node, type_info='dataset_info'):
         """
@@ -597,7 +602,7 @@ class DAQScan(QObject, ParameterManager):
         for ind, pos in enumerate(positions):
             dte.append(DataActuator(actuators[ind].title, data=float(pos)))
 
-        self.modules_manager.move_actuators(dte)
+        self.modules_manager.move_actuators(dte, polling=False)
 
     def value_changed(self, param):
         """
@@ -616,23 +621,52 @@ class DAQScan(QObject, ParameterManager):
         self.settings.child('plot_options', 'plot_0d').setValue(dict(all_items=[], selected=[]))
         self.settings.child('plot_options', 'plot_1d').setValue(dict(all_items=[], selected=[]))
 
-    def prepare_viewers(self):
+    def check_number_type_viewers(self) -> Tuple[
+        List[ViewersEnum],
+        List[str],
+        bool]:
+        """ Assert from selected options the number and type of needed viewers for live plotting
 
-        viewers_enum = [ViewersEnum('Data0D').increase_dim(self.scanner.n_axes)
+        Return
+        ------
+        List[ViewersEnum]: the list of needed viewers
+         List[str]: the list of data names to be plotted in the corresponding viewer
+        """
+        viewer2D_overload = False
+        viewers_enum = [ViewersEnum.Viewer0D.increase_dim(self.scanner.n_axes)
                         for _ in range(len(self.settings['plot_options', 'plot_0d']['selected']))]
         data_names = self.settings['plot_options', 'plot_0d']['selected'][:]
 
-        if self.settings['plot_options', 'group0D'] and len(viewers_enum) > 0 and ViewersEnum('Data1D') in viewers_enum:
-            viewers_enum = [ViewersEnum('Data1D')]
+        if self.settings['plot_options', 'group0D'] and len(viewers_enum) > 0 and ViewersEnum.Viewer1D in viewers_enum:
+            viewers_enum = [ViewersEnum.Viewer1D]
             data_names = [self.live_plotter.grouped_data0D_fullname]
-        elif self.settings['plot_options', 'group0D'] and len(viewers_enum) > 0 and ViewersEnum('Data2D') in viewers_enum:
-            viewers_enum = [ViewersEnum('Data2D')]
+        elif (self.settings['plot_options', 'group0D'] and len(viewers_enum) > 0 and
+              ViewersEnum.Viewer2D in viewers_enum):
+            viewers_enum = [ViewersEnum.Viewer2D]
+            n2Dplots = len(data_names)
+            if (self.settings['scan_options', 'scan_average'] > 1 and
+                self.settings['scan_options', 'average_on_top']):
+                n2Dplots *= 2
+            if n2Dplots > 3:
+                viewer2D_overload = True
             data_names = [self.live_plotter.grouped_data0D_fullname]
 
         if self.scanner.n_axes <= 1:
-            viewers_enum.extend([ViewersEnum('Data1D').increase_dim(self.scanner.n_axes)
+            viewers_enum.extend([ViewersEnum.Viewer1D.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]
+
+        return viewers_enum, data_names, viewer2D_overload
+
+    def prepare_viewers(self):
+        """ Assert from selected options the number and type of needed viewers for live plotting
+        and prepare them on the live plot panel
+        """
+        viewers_enum, data_names, _ = self.check_number_type_viewers()
         self.live_plotter.prepare_viewers(viewers_enum, viewers_name=data_names)
 
     def update_status(self, txt: str, wait_time=0):
@@ -672,6 +706,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()
@@ -736,6 +771,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
@@ -767,11 +803,22 @@ class DAQScan(QObject, ParameterManager):
                          f"limit in the config file ({config['scan']['steps_limit']}) or modify"
                          f" your scan settings.")
 
+            _, _, viewer2D_overload = self.check_number_type_viewers()
+            if viewer2D_overload:
+                messagebox(text=
+                           'The number of live data chosen and the selected options '
+                           'will not be able to render fully on the 2D live viewers. Consider changing '
+                           'the options, such as "plot on top" for the averaging or "Group 0D data" '
+                           'or the number of selected data')
+                return False
+
             if self.modules_manager.Nactuators != self.scanner.n_axes:
                 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:
@@ -860,9 +907,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
@@ -1029,20 +1082,20 @@ class DAQScanAcquisition(QObject):
             self.set_ini_positions()
 
         elif command.command == "move_stages":
-            self.modules_manager.move_actuators(command.attribute)
+            self.modules_manager.move_actuators(command.attribute, polling=False)
 
     def set_ini_positions(self):
         """ Set the actuators's positions totheir initial value as defined in the scanner  """
         try:
             if self.scanner.scan_sub_type != 'Adaptive':
-                self.modules_manager.move_actuators(self.scanner.positions_at(0))
+                self.modules_manager.move_actuators(self.scanner.positions_at(0), polling=False)
 
         except Exception as e:
             logger.exception(str(e))
 
     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()
@@ -1114,6 +1167,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)
 
@@ -1121,6 +1175,7 @@ class DAQScanAcquisition(QObject):
                                                      attribute="Acquisition has finished"))
             self.status_sig.emit(utils.ThreadCommand("Scan_done"))
 
+
         except Exception as e:
             logger.exception(str(e))
 
@@ -1156,7 +1211,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-5.0.1 → pymodaq-5.0.3}/src/pymodaq/extensions/pid/pid_controller.py

@@ -166,7 +166,7 @@ class DAQ_PID(CustomExt):
     def process_output(self, data: DataToExport):
         inputs: DataRaw = data.get_data_from_name('inputs')
         outputs: DataRaw = data.get_data_from_name('outputs')
-        self.curr_points = [float(d) for d in inputs]
+        self.curr_points = [float(array[0]) for array in inputs]
         self.output_viewer.show_data(outputs)
         self.input_viewer.show_data(inputs)
 

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/extensions/pid/utils.py

@@ -137,38 +137,14 @@ class PIDModelGeneric:
 
 
 def main(xmlfile):
-    from pymodaq.dashboard import DashBoard
-    from pymodaq.utils.config import get_set_preset_path
+    from pymodaq.utils.gui_utils.loader_utils import load_dashboard_with_preset
     from pathlib import Path
     from qtpy import QtWidgets
+    from pymodaq_gui.utils.utils import mkQApp
 
     import sys
-    app = QtWidgets.QApplication(sys.argv)
-    win = QtWidgets.QMainWindow()
-    area = DockArea()
-    win.setCentralWidget(area)
-    win.resize(1000, 500)
-    win.setWindowTitle('PyMoDAQ Dashboard')
-
-    dashboard = DashBoard(area)
-    file = Path(get_set_preset_path()).joinpath(xmlfile)
-    if file.exists():
-        dashboard.set_preset_mode(file)
-        # prog.load_scan_module()
-        pid_area = DockArea()
-        pid_window = QtWidgets.QMainWindow()
-        pid_window.setCentralWidget(pid_area)
-
-        prog = dashboard.load_pid_module(pid_window)
-
-    else:
-        msgBox = QtWidgets.QMessageBox()
-        msgBox.setText(f"The default file specified in the configuration file does not exists!\n"
-                       f"{file}\n"
-                       f"Impossible to load the DAQ_PID Module")
-        msgBox.setStandardButtons(msgBox.Ok)
-        ret = msgBox.exec()
-
+    app = mkQApp('BeamSteering')
+    dashboard, extension, win = load_dashboard_with_preset(xmlfile, 'DAQ_PID')
     sys.exit(app.exec_())
 
 
@@ -180,7 +156,6 @@ def get_models(model_name=None):
     -------
     list: list of disct containting the name and python module of the found models
     """
-    from pymodaq.extensions.pid.utils import PIDModelGeneric
     models_import = []
     discovered_models = list(get_entrypoints(group='pymodaq.pid_models'))
     discovered_models.extend(list(get_entrypoints(group='pymodaq.models')))

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/post_treatment/load_and_plot.py

@@ -70,7 +70,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
 
@@ -92,6 +92,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
         -------
@@ -102,7 +104,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]
@@ -113,14 +116,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
@@ -132,7 +136,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:
@@ -143,10 +152,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
@@ -159,18 +174,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,
@@ -179,6 +203,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-5.0.1 → pymodaq-5.0.3}/src/pymodaq/utils/data.py

@@ -9,9 +9,16 @@ from pymodaq_utils.warnings import deprecation_msg, user_warning
 
 from pymodaq_data.data import (DataRaw, DataWithAxes, DataToExport, DataCalculated, DataDim,
                                DataSource, DataBase, Axis, NavAxis, DataDistribution, Q_, Unit,
-                               )  # imported here for backcompatibility
+                               )  # imported here for backcompatibility. Will allow also the object serialization
+                                  # registration
 
 
+from pymodaq_utils.serialize.factory import SerializableFactory, SerializableBase
+
+ser_factory = SerializableFactory()
+
+
+@ser_factory.register_decorator()
 class DataActuator(DataRaw):
     """Specialized DataWithAxes set with source as 'raw'.
     To be used for raw data generated by actuator plugins"""
@@ -40,6 +47,7 @@ class DataActuator(DataRaw):
             return super().__add__(other)
 
 
+@ser_factory.register_decorator()
 class DataFromPlugins(DataRaw):
     """Specialized DataWithAxes set with source as 'raw'. To be used for raw data generated by Detector plugins
 
@@ -83,12 +91,14 @@ class DataFromPlugins(DataRaw):
         super().__init__(*args, **kwargs)
 
 
+@ser_factory.register_decorator()
 class DataScan(DataToExport):
     """Specialized DataToExport.To be used for data to be saved """
     def __init__(self, name: str, data: List[DataWithAxes] = [], **kwargs):
         super().__init__(name, data, **kwargs)
 
 
+@ser_factory.register_decorator()
 class DataToActuators(DataToExport):
     """ Particular case of a DataToExport adding one named parameter to indicate what kind of change
     should be applied to the actuators, absolute or relative
@@ -115,4 +125,3 @@ class DataToActuators(DataToExport):
 
     def __repr__(self):
         return f'{super().__repr__()}: {self.mode}'
-

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/utils/gui_utils/loader_utils.py

@@ -39,6 +39,8 @@ def load_dashboard_with_preset(preset_name: str, extension_name: str) -> \
     # win.setVisible(False)
     dashboard = DashBoard(area)
 
+    preset_name = Path(preset_name).stem
+
     file = Path(get_set_preset_path()).joinpath(f"{preset_name}.xml")
 
     if file is not None and file.exists():

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/utils/h5modules/module_saving.py

@@ -11,7 +11,7 @@ import xml.etree.ElementTree as ET
 
 
 import numpy as np
-
+from pymodaq_utils.logger import set_logger, get_module_name
 from pymodaq_utils.abstract import ABCMeta, abstract_attribute, abstractmethod
 from pymodaq_utils.utils import capitalize
 from pymodaq_data.data import Axis, DataDim, DataWithAxes, DataToExport, DataDistribution
@@ -28,6 +28,9 @@ if TYPE_CHECKING:
     from pymodaq.extensions.daq_logger.h5logging import H5Logger
 
 
+logger = set_logger(get_module_name(__file__))
+
+
 class ModuleSaver(metaclass=ABCMeta):
     """Abstract base class to save info and data from main modules (DAQScan, DAQViewer, DAQMove, ...)"""
     group_type: GroupType = abstract_attribute()
@@ -374,7 +377,7 @@ class ScanSaver(ModuleSaver):
             try:
                 detector.insert_data(indexes, where=self._module_group, distribution=distribution)
             except Exception as e:
-                pass
+                logger.exception(f'Cannot insert data: {str(e)}')
 
 
 class LoggerSaver(ScanSaver):

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/utils/leco/daq_move_LECODirector.py

@@ -17,8 +17,7 @@ from pymodaq_gui.parameter import Parameter
 
 from pymodaq.utils.leco.leco_director import LECODirector, leco_parameters
 from pymodaq.utils.leco.director_utils import ActuatorDirector
-from pymodaq.utils.tcp_ip.serializer import DeSerializer
-
+from pymodaq_utils.serialize.serializer_legacy import DeSerializer
 
 class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
     """A control module, which in the dashboard, allows to control a remote Move module.

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/utils/leco/daq_xDviewer_LECODirector.py

@@ -6,8 +6,9 @@ from easydict import EasyDict as edict
 from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base, comon_parameters, main
 
 from pymodaq_utils.utils import ThreadCommand, getLineInfo
+
 from pymodaq_gui.parameter import Parameter
-from pymodaq.utils.tcp_ip.serializer import DeSerializer
+from pymodaq_utils.serialize.serializer_legacy import DeSerializer
 
 from pymodaq.utils.leco.leco_director import LECODirector, leco_parameters
 from pymodaq.utils.leco.director_utils import DetectorDirector

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/utils/leco/leco_director.py

@@ -1,8 +1,9 @@
-
 import random
-
 from typing import Callable, Sequence, List
 
+from pymodaq_utils.enums import StrEnum
+from typing import Callable, Sequence, List, Optional, Union
+
 import pymodaq_gui.parameter.utils as putils
 # object used to send info back to the main thread:
 from pymodaq_utils.utils import ThreadCommand
@@ -14,7 +15,7 @@ from pymodaq.utils.leco.pymodaq_listener import PymodaqListener
 
 leco_parameters = [
     {'title': 'Actor name:', 'name': 'actor_name', 'type': 'str', 'value': "actor_name",
-     'text': 'Name of the actor plugin to communicate with.'},
+     'tip': 'Name of the actor plugin to communicate with.'},
 ]
 
 

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/utils/leco/pymodaq_listener.py

@@ -1,11 +1,6 @@
 
-try:
-    from enum import StrEnum  # type: ignore
-except ImportError:
-    from enum import Enum
+from pymodaq_utils.enums import StrEnum
 
-    class StrEnum(str, Enum):
-        pass
 import logging
 from threading import Event
 from typing import Optional, Union, List, Type

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/utils/leco/utils.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 import subprocess
 import sys
 from typing import Any, Optional, Union, get_args, TypeVar
-from pymodaq_data import data
+
 from pymodaq.utils import data
 # import also the DeSerializer for easier imports in dependents
 from pymodaq_utils.serialize.serializer_legacy import Serializer, DeSerializer, SerializableFactory
+
 # type: ignore  # noqa
 from pymodaq_utils.logger import set_logger
 
@@ -14,7 +15,6 @@ logger = set_logger('leco_utils')
 ser_factory = SerializableFactory()
 JSON_TYPES = Union[str, int, float]
 
-SERIALIZABLE = ser_factory.get_serializables()
 
 
 def serialize_object(pymodaq_object: Union[SERIALIZABLE, Any]) -> Union[str, Any]:
@@ -26,6 +26,13 @@ def serialize_object(pymodaq_object: Union[SERIALIZABLE, Any]) -> Union[str, Any
     #is not serializable
 
 
+## this form below is to be compatible with python <= 3.10
+## for py>= 3.11 this could be written SERIALIZABLE = Union[ser_factory.get_serializables()]
+SERIALIZABLE = Union[ser_factory.get_serializables()[0]]
+for klass in ser_factory.get_serializables()[1:]:
+    SERIALIZABLE = Union[SERIALIZABLE, klass]
+
+
 def binary_serialization(
     pymodaq_object: Union[SERIALIZABLE, Any],
 ) -> tuple[Optional[Any], Optional[list[bytes]]]:

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/utils/managers/modules_manager.py

@@ -374,12 +374,12 @@ class ModulesManager(QObject, ParameterManager):
                 sig.connect(slot)
         else:
 
-            for sig in [mod.grab_done_signal for mod in self.detectors_all]:
+            for sig in [mod.grab_done_signal for mod in self.detectors]:
                 try:
                     sig.disconnect(slot)
                 except TypeError as e:
                     # means the slot was not previously connected
-                    logger.info(str(e))
+                    logger.info(f'Could not disconnect grab signal from the {slot} slot', stacklevel=2)
 
         self.detectors_connected = connect
 

{pymodaq-5.0.1 → pymodaq-5.0.3}/src/pymodaq/utils/tcp_ip/serializer.py

@@ -7,7 +7,7 @@ Created the 20/10/2023
 
 from pymodaq_utils.utils import deprecation_msg
 
-from pymodaq_data.serialize.serializer_legacy import Serializer, DeSerializer, SocketString, Socket
+from pymodaq_utils.serialize.serializer_legacy import Serializer, DeSerializer, SocketString, Socket
 
 deprecation_msg('Importing Serializer, DeSerializer from pymodaq is deprecated in PyMoDAQ >= 5,'
                 'import them from pymodaq_data.serialize.serializer')