pymodaq 3.6.13__py3-none-any.whl → 4.0.1__py3-none-any.whl

pymodaq/{daq_utils → utils}/managers/modules_manager.py

@@ -1,19 +1,38 @@
-from typing import List
+from typing import List, Union
+
 from collections import OrderedDict
 from qtpy.QtCore import QObject, Signal, Slot, QThread
 from qtpy import QtWidgets
 import time
-from pymodaq.daq_utils import daq_utils as utils
 
+from pymodaq.utils.logger import set_logger, get_module_name, get_module_name
+from pymodaq.utils import daq_utils as utils
+from pymodaq.utils.config import Config
+from pymodaq.utils.data import DataToExport, DataFromPlugins
 from pyqtgraph.parametertree import Parameter, ParameterTree
+from pymodaq.utils.managers.parameter_manager import ParameterManager
+
+logger = set_logger(get_module_name(__file__))
+config = Config()
 
-logger = utils.set_logger(utils.get_module_name(__file__))
 
+class ModulesManager(QObject, ParameterManager):
+    """Class to manage DAQ_Viewers and DAQ_Moves with UI to select some
 
-class ModulesManager(QObject):
+    Easier to connect control modules signals to slots, test, ...
+
+    Parameters
+    ----------
+    detectors: list of DAQ_Viewer
+    actuators: list of DAQ_Move
+    selected_detectors: list of DAQ_Viewer
+        sublist of detectors
+    selected_actuators: list of DAQ_Move
+        sublist of actuators
+    """
     detectors_changed = Signal(list)
     actuators_changed = Signal(list)
-    det_done_signal = Signal(OrderedDict)
+    det_done_signal = Signal(DataToExport)
     move_done_signal = Signal(OrderedDict)
     timeout_signal = Signal(bool)
 
@@ -39,28 +58,23 @@ class ModulesManager(QObject):
         ]},
     ]
 
-    def __init__(self, detectors=[], actuators=[], selected_detectors=[], selected_actuators=[], timeout=10000):
-        super().__init__()
+    def __init__(self, detectors=[], actuators=[], selected_detectors=[], selected_actuators=[], **kwargs):
+        QObject.__init__(self)
+        ParameterManager.__init__(self)
 
         for mod in selected_actuators:
             assert mod in actuators
         for mod in selected_detectors:
             assert mod in detectors
 
-        self.timeout = timeout  # in ms
+        self.actuator_timeout = config('actuator', 'timeout')
+        self.detector_timeout = config('viewer', 'timeout')
 
-        self.det_done_datas = OrderedDict()
+        self.det_done_datas: DataToExport = None
         self.det_done_flag = False
         self.move_done_positions = OrderedDict()
         self.move_done_flag = False
 
-        self.settings = Parameter.create(name='Settings', type='group', children=self.params)
-        self.settings_tree = ParameterTree()
-        self.settings_tree.setMinimumWidth(300)
-        self.settings_tree.setParameters(self.settings, showTop=False)
-
-        self.settings.sigTreeStateChanged.connect(self.parameter_tree_changed)
-
         self.settings.child('data_dimensions', 'probe_data').sigActivated.connect(self.get_det_data_list)
         self.settings.child('actuators_positions', 'test_actuator').sigActivated.connect(self.test_move_actuators)
 
@@ -76,13 +90,33 @@ class ModulesManager(QObject):
         self.set_actuators(actuators, selected_actuators)
         self.set_detectors(detectors, selected_detectors)
 
+    def show_only_control_modules(self, show: True):
+        self.settings.child('move_done').show(not show)
+        self.settings.child('det_done').show(not show)
+        self.settings.child('data_dimensions').show(not show)
+        self.settings.child('actuators_positions').show(not show)
+
     @classmethod
     def get_names(cls, modules):
+        """Get the titles of a list of Control Modules
+
+        Parameters
+        ----------
+        modules: list of DAQ_Move and/or DAQ_Viewer
+        """
         if not hasattr(modules, '__iter__'):
             modules = [modules]
         return [mod.title for mod in modules]
 
     def get_mods_from_names(self, names, mod='det'):
+        """Getter of a list of given modules from their name (title)
+
+        Parameters
+        ----------
+        names: list of str
+        mod: str
+            either 'det' for DAQ_Viewer modules or 'act' for DAQ_Move modules
+        """
         mods = []
         for name in names:
             d = self.get_mod_from_name(name, mod)
@@ -90,7 +124,15 @@ class ModulesManager(QObject):
                 mods.append(d)
         return mods
 
-    def get_mod_from_name(self, name, mod='det'):
+    def get_mod_from_name(self, name, mod='det') -> Union['DAQ_Move', 'DAQ_Viewer']:
+        """Getter of a given module from its name (title)
+
+        Parameters
+        ----------
+        name: str
+        mod: str
+            either 'det' for DAQ_Viewer modules or 'act' for DAQ_Move modules
+        """
         if mod == 'det':
             modules = self._detectors
         else:
@@ -103,45 +145,65 @@ class ModulesManager(QObject):
             return None
 
     def set_actuators(self, actuators, selected_actuators):
+        """Populates actuators and the subset to be selected in the UI"""
         self._actuators = actuators
         self.settings.child('modules', 'actuators').setValue(dict(all_items=self.get_names(actuators),
                                                                   selected=self.get_names(selected_actuators)))
 
     def set_detectors(self, detectors, selected_detectors):
+        """Populates detectors and the subset to be selected in the UI"""
         self._detectors = detectors
         self.settings.child('modules', 'detectors').setValue(dict(all_items=self.get_names(detectors),
                                                                   selected=self.get_names(selected_detectors)))
 
     @property
-    def detectors(self):
+    def detectors(self) -> List['DAQ_Viewer']:
+        """Get the list of selected detectors"""
         return self.get_mods_from_names(self.selected_detectors_name)
 
     @property
     def detectors_all(self):
+        """Get the list of all detectors"""
         return self._detectors
 
     @property
     def actuators(self) -> List['DAQ_Move']:
+        """Get the list of selected actuators"""
         return self.get_mods_from_names(self.selected_actuators_name, mod='act')
 
     @property
     def actuators_all(self):
+        """Get the list of all actuators"""
         return self._actuators
 
+    @property
+    def modules(self):
+        """Get the list of all detectors and actuators"""
+        return self.detectors + self.actuators
+
+    @property
+    def modules_all(self):
+        """Get the list of all detectors and actuators"""
+        return self.detectors_all + self.actuators_all
+
     @property
     def Ndetectors(self):
+        """Get the number of selected detectors"""
         return len(self.detectors)
 
     @property
     def Nactuators(self):
+        """Get the number of selected actuators"""
         return len(self.actuators)
 
     @property
     def detectors_name(self):
+        """Get all the names of the detectors"""
         return self.settings.child('modules', 'detectors').value()['all_items']
 
     @property
     def selected_detectors_name(self):
+        """Get/Set the names of the selected detectors"""
         return self.settings.child('modules', 'detectors').value()['selected']
 
     @selected_detectors_name.setter
@@ -152,10 +214,12 @@ class ModulesManager(QObject):
 
     @property
     def actuators_name(self):
+        """Get all the names of the actuators"""
         return self.settings.child('modules', 'actuators').value()['all_items']
 
     @property
-    def selected_actuators_name(self):
+    def selected_actuators_name(self) -> List[str]:
+        """Get/Set the names of the selected actuators"""
         return self.settings.child('modules', 'actuators').value()['selected']
 
     @selected_actuators_name.setter
@@ -164,53 +228,23 @@ class ModulesManager(QObject):
             self.settings.child('modules', 'actuators').setValue(dict(all_items=self.actuators_name,
                                                                       selected=actuators))
 
+    def value_changed(self, param):
+        if param.name() == 'detectors':
+            self.detectors_changed.emit(param.value()['selected'])
 
-    def parameter_tree_changed(self, param, changes):
-        """
-            Check for changes in the given (parameter,change,information) tuple list.
-            In case of value changed, update the DAQscan_settings tree consequently.
-
-            =============== ============================================ ==============================
-            **Parameters**    **Type**                                     **Description**
-            *param*           instance of pyqtgraph parameter              the parameter to be checked
-            *changes*         (parameter,change,information) tuple list    the current changes state
-            =============== ============================================ ==============================
-        """
-        for param, change, data in changes:
-            path = self.settings.childPath(param)
-            if change == 'childAdded':
-                pass
-
-            elif change == 'value':
-
-                if param.name() == 'detectors':
-                    self.detectors_changed.emit(data['selected'])
-
-                elif param.name() == 'actuators':
-                    self.actuators_changed.emit(data['selected'])
-
-            elif change == 'parent':
-                pass
+        elif param.name() == 'actuators':
+            self.actuators_changed.emit(param.value()['selected'])
 
     def get_det_data_list(self):
-        self.connect_detectors()
+        """Do a snap of selected detectors, to get the list of all the data and processed data"""
 
-        datas = self.grab_datas()
-
-        data_list0D = []
-        data_list1D = []
-        data_list2D = []
-        data_listND = []
+        self.connect_detectors()
+        datas: DataToExport = self.grab_datas()
 
-        for k in datas.keys():
-            if 'data0D' in datas[k].keys():
-                data_list0D.extend([f'{k}/{name}' for name in datas[k]['data0D'].keys()])
-            if 'data1D' in datas[k].keys():
-                data_list1D.extend([f'{k}/{name}' for name in datas[k]['data1D'].keys()])
-            if 'data2D' in datas[k].keys():
-                data_list2D.extend([f'{k}/{name}' for name in datas[k]['data2D'].keys()])
-            if 'dataND' in datas[k].keys():
-                data_listND.extend([f'{k}/{name}' for name in datas[k]['dataND'].keys()])
+        data_list0D = datas.get_full_names('data0D')
+        data_list1D = datas.get_full_names('data1D')
+        data_list2D = datas.get_full_names('data2D')
+        data_listND = datas.get_full_names('dataND')
 
         self.settings.child('data_dimensions', 'det_data_list0D').setValue(
             dict(all_items=data_list0D, selected=[]))
@@ -224,22 +258,31 @@ class ModulesManager(QObject):
         self.connect_detectors(False)
 
     def get_selected_probed_data(self, dim='0D'):
+        """Get the name of selected data names of a given dimensionality
+
+        Parameters
+        ----------
+        dim: str
+            either '0D', '1D', '2D' or 'ND'
+        """
         return self.settings.child('data_dimensions', f'det_data_list{dim.upper()}').value()['selected']
 
     def grab_datas(self, **kwargs):
-        self.det_done_datas = OrderedDict()
+        """Do a single grab of connected and selected detectors"""
+        self.det_done_datas = DataToExport(name=__class__.__name__, control_module='DAQ_Viewer')
+        self._received_data = 0
         self.det_done_flag = False
-        self.settings.child(('det_done')).setValue(self.det_done_flag)
+        self.settings.child('det_done').setValue(self.det_done_flag)
         tzero = time.perf_counter()
 
-        for sig in [mod.command_detector for mod in self.detectors]:
+        for sig in [mod.command_hardware for mod in self.detectors]:
             sig.emit(utils.ThreadCommand("single", [1, kwargs]))
 
         while not self.det_done_flag:
             # wait for grab done signals to end
 
             QtWidgets.QApplication.processEvents()
-            if time.perf_counter() - tzero > self.timeout:
+            if time.perf_counter() - tzero > self.detector_timeout:
                 self.timeout_signal.emit(True)
                 logger.error('Timeout Fired during waiting for data to be acquired')
                 break
@@ -247,16 +290,36 @@ class ModulesManager(QObject):
         self.det_done_signal.emit(self.det_done_datas)
         return self.det_done_datas
 
-    def connect_actuators(self, connect=True, slot=None):
+    def connect_actuators(self, connect=True, slot=None, signal='move_done'):
+        """Connect the selected actuators signal to a given or default slot
+
+        Parameters
+        ----------
+        connect: bool
+        slot: builtin_function_or_method
+            method or function the chosen signal will be connected to
+            if None, then the default move_done slot is used
+        signal: str
+            What kind of signal is to be used:
+
+            * 'move_done' will connect the `move_done signal` to the slot
+            * 'current_value' will connect the 'current_signal' to the slot
+
+        See Also
+        --------
+        :meth:`move_done`
+        """
         if slot is None:
             slot = self.move_done
         if connect:
-            for sig in [mod.move_done_signal for mod in self.actuators]:
+            for sig in [mod.move_done_signal if signal == 'move_done' else mod.current_value_signal
+                        for mod in self.actuators]:
                 sig.connect(slot)
 
         else:
             try:
-                for sig in [mod.move_done_signal for mod in self.actuators]:
+                for sig in [mod.move_done_signal if signal == 'move_done' else mod.current_value_signal
+                            for mod in self.actuators]:
                     sig.disconnect(slot)
             except Exception as e:
                 logger.error(str(e))
@@ -266,15 +329,18 @@ class ModulesManager(QObject):
     def connect_detectors(self, connect=True, slot=None):
         """
         Connect selected DAQ_Viewers's grab_done_signal to the given slot
+
         Parameters
         ----------
-        connect: (bool) if True, connect to the given slot (or default slot)
-                        if False, disconnect all detectors (not only the currently selected ones.
-                        This is made because when selected detectors changed if you only disconnect those ones,
-                        the previously connected ones will stay connected)
-
-        slot: (method) A method that should be connected
+        connect: bool
+            if True, connect to the given slot (or default slot)
+            if False, disconnect all detectors (not only the currently selected ones.
+            This is made because when selected detectors changed if you only disconnect those one,
+            the previously connected ones will stay connected)
+        slot: method
+            A method that should be connected, if None self.det_done is connected by default
         """
+
         if slot is None:
             slot = self.det_done
 
@@ -293,6 +359,7 @@ class ModulesManager(QObject):
         self.detectors_connected = connect
 
     def test_move_actuators(self):
+        """Do a move of selected actuator"""
         positions = dict()
         for act in self.get_names(self.actuators):
             pos, done = QtWidgets.QInputDialog.getDouble(None, f'Enter a target position for actuator {act}',
@@ -316,28 +383,27 @@ class ModulesManager(QObject):
 
         Parameters
         ----------
-        positions: (list) the list of position to apply. Its length must be equal to the number of selected actutors
-        mode: (str) either 'abs' for absolute positionning or 'rel' for relative
-        poll: (bool) if True will wait for the selected actuators to reach their target positions (they have to be
-        connected to a method checking for the position and letting the programm know the move is done (default
-        connection is this object `move_done` method)
+        positions: list
+            the list of position to apply. Its length must be equal to the number of selected actutors
+        mode: str
+            either 'abs' for absolute positionning or 'rel' for relative
+        polling: bool
+            if True will wait for the selected actuators to reach their target positions (they have to be
+            connected to a method checking for the position and letting the programm know the move is done (default
+            connection is this object `move_done` method)
 
         Returns
         -------
         (OrderedDict) with the selected actuators's name as key and current actuators's value as value
-
-        See Also
-        --------
-        move_done
         """
         self.move_done_positions = OrderedDict()
         self.move_done_flag = False
-        self.settings.child(('move_done')).setValue(self.move_done_flag)
+        self.settings.child('move_done').setValue(self.move_done_flag)
 
         if mode == 'abs':
-            command = 'move_Abs'
+            command = 'move_abs'
         elif mode == 'rel':
-            command = 'move_Rel'
+            command = 'move_rel'
         else:
             logger.error(f'Invalid positioning mode: {mode}')
             return self.move_done_positions
@@ -350,10 +416,13 @@ class ModulesManager(QObject):
                 for k in positions:
                     act = self.get_mod_from_name(k, 'act')
                     if act is not None:
-                        act.command_stage.emit(utils.ThreadCommand(command=command, attributes=[positions[k], polling]))
+                        #getattr(act, command)(positions[k])
+                        act.command_hardware.emit(
+                            utils.ThreadCommand(command=command, attribute=[positions[k], polling]))
             else:
                 for ind, act in enumerate(self.actuators):
-                    act.command_stage.emit(utils.ThreadCommand(command=command, attributes=[positions[ind], polling]))
+                    #getattr(act, command)(positions[ind])
+                    act.command_hardware.emit(utils.ThreadCommand(command=command, attribute=[positions[ind], polling]))
 
         else:
             logger.error('Invalid number of positions compared to selected actuators')
@@ -364,15 +433,19 @@ class ModulesManager(QObject):
             while not self.move_done_flag:  # polling move done
 
                 QtWidgets.QApplication.processEvents()
-                if time.perf_counter() - tzero > self.timeout:
+                if time.perf_counter() - tzero > self.actuator_timeout / 1000:  # timeout in seconds
                     self.timeout_signal.emit(True)
-                    logger.error('Timeout Fired during waiting for data to be acquired')
+                    logger.error('Timeout Fired during waiting for actuators to be moved')
                     break
                 QThread.msleep(20)
 
         self.move_done_signal.emit(self.move_done_positions)
         return self.move_done_positions
 
+    def reset_signals(self):
+        self.move_done_flag = True
+        self.det_done_flag = True
+
     def order_positions(self, positions_as_dict):
         actuators = self.selected_actuators_name
         pos = []
@@ -380,11 +453,8 @@ class ModulesManager(QObject):
             pos.append(positions_as_dict[act])
         return pos
 
-    Slot(str, float)
-
+    @Slot(str, float)
     def move_done(self, name, position):
-        """
-        """
         try:
             if name not in list(self.move_done_positions.keys()):
                 self.move_done_positions[name] = position
@@ -395,16 +465,20 @@ class ModulesManager(QObject):
         except Exception as e:
             logger.exception(str(e))
 
-    @Slot(OrderedDict)
-    def det_done(self, data):
-        try:
-            if data['name'] not in list(self.det_done_datas.keys()):
-                self.det_done_datas[data['name']] = data
-            if len(self.det_done_datas.items()) == len(self.detectors):
+    def det_done(self, data: DataToExport):
+        if self.det_done_datas is not None:  # means that somehow data are not initialized so no further processing
+            self._received_data += 1
+            if len(data) != 0:
+                self.det_done_datas.append(data)
+
+            if self._received_data == len(self.detectors):
                 self.det_done_flag = True
-                self.settings.child(('det_done')).setValue(self.det_done_flag)
-        except Exception as e:
-            logger.exception(str(e))
+                self.settings.child('det_done').setValue(self.det_done_flag)
+
+        # if data.name not in list(self.det_done_datas.keys()):
+        #     self.det_done_datas[data['name']] = data
+        # if len(self.det_done_datas.items()) == len(self.detectors):
+        #     self.det_done_flag = True
 
 
 if __name__ == '__main__':
@@ -412,10 +486,10 @@ if __name__ == '__main__':
 
     app = QtWidgets.QApplication(sys.argv)
     from qtpy.QtCore import QThread
-    from pymodaq.daq_utils.gui_utils import DockArea
+    from pymodaq.utils.gui_utils import DockArea
     from pyqtgraph.dockarea import Dock
-    from pymodaq.daq_viewer.daq_viewer_main import DAQ_Viewer
-    from pymodaq.daq_move.daq_move_main import DAQ_Move
+    from pymodaq.control_modules.daq_viewer import DAQ_Viewer
+    from pymodaq.control_modules.daq_move import DAQ_Move
 
     win = QtWidgets.QMainWindow()
     area = DockArea()
@@ -423,9 +497,9 @@ if __name__ == '__main__':
     win.resize(1000, 500)
     win.setWindowTitle('pymodaq main')
 
-    prog = DAQ_Viewer(area, title="Testing2D", DAQ_type='DAQ2D')
-    prog2 = DAQ_Viewer(area, title="Testing1D", DAQ_type='DAQ1D')
-    prog3 = DAQ_Viewer(area, title="Testing0D", DAQ_type='DAQ0D')
+    prog = DAQ_Viewer(area, title="Testing2D", daq_type='DAQ2D')
+    prog2 = DAQ_Viewer(area, title="Testing1D", daq_type='DAQ1D')
+    prog3 = DAQ_Viewer(area, title="Testing0D", daq_type='DAQ0D')
 
     act1_widget = QtWidgets.QWidget()
     act2_widget = QtWidgets.QWidget()
@@ -433,9 +507,9 @@ if __name__ == '__main__':
     act2 = DAQ_Move(act2_widget, title='Y_axis')
 
     QThread.msleep(1000)
-    prog.ui.IniDet_pb.click()
-    prog2.ui.IniDet_pb.click()
-    prog3.ui.IniDet_pb.click()
+    prog.init_hardware_ui()
+    prog2.init_hardware_ui()
+    prog3.init_hardware_ui()
 
     dock1 = Dock('actuator 1')
     dock1.addWidget(act1_widget)
@@ -445,8 +519,8 @@ if __name__ == '__main__':
     dock2.addWidget(act2_widget)
     area.addDock(dock2)
 
-    act1.ui.IniStage_pb.click()
-    act2.ui.IniStage_pb.click()
+    act1.init_hardware_ui()
+    act2.init_hardware_ui()
 
     QtWidgets.QApplication.processEvents()
     win.show()

pymodaq/{daq_utils → utils}/managers/overshoot_manager.py

@@ -2,14 +2,14 @@ from qtpy import QtWidgets
 import sys
 import os
 
-from pymodaq.daq_utils.parameter import ioxml
+from pymodaq.utils.parameter import ioxml
 from pyqtgraph.parametertree import Parameter, ParameterTree
 from pyqtgraph.parametertree.Parameter import registerParameterType
 from pyqtgraph.parametertree.parameterTypes.basetypes import GroupParameter
-from pymodaq.daq_utils.gui_utils import select_file
+from pymodaq.utils.gui_utils import select_file
 
 # check if overshoot_configurations directory exists on the drive
-from pymodaq.daq_utils.config import get_set_overshoot_path
+from pymodaq.utils.config import get_set_overshoot_path
 
 overshoot_path = get_set_overshoot_path()