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

pymodaq/daq_utils.py

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 27/10/2022
+
+@author: Sebastien Weber
+"""
+import sys
+from importlib import import_module
+
+from pymodaq.utils.messenger import deprecation_msg
+
+deprecation_msg('Importing from pymodaq.daq_utils is deprecated, use pymodaq.utils.'
+                'It will cause an error in version 4.1.0', 3)
+# import_module('.utils', 'pymodaq')
+# sys.modules['pymodaq.daq_utils'] = import_module('.utils', 'pymodaq')
+# sys.modules['pymodaq.daq_utils.abstract.logger'] = import_module('.abstract.logger', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.array_manipulation'] = import_module('.array_manipulation', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.calibration_camera'] = import_module('.calibration_camera', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.chrono_timer'] = import_module('.chrono_timer', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.config'] = import_module('.config', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.conftests'] = import_module('.conftests', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.daq_enums'] = import_module('.enums', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.daq_utils'] = import_module('.daq_utils', 'pymodaq.utils')
+# try:
+#     import sqlalchemy
+#     sys.modules['pymodaq.daq_utils.db.db_logger.db_logger'] = import_module('.db.db_logger.db_logger', 'pymodaq.utils')
+#     sys.modules['pymodaq.daq_utils.db.db_logger.db_logger_models'] = import_module('.db.db_logger.db_logger_models', 'pymodaq.utils')
+# except ModuleNotFoundError:
+#     pass
+# sys.modules['pymodaq.daq_utils.exceptions'] = import_module('.exceptions', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.gui_utils.custom_app'] = import_module('.gui_utils.custom_app', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.gui_utils.dock'] = import_module('.gui_utils.dock', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.gui_utils.file_io'] = import_module('.gui_utils.file_io', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.gui_utils.layout'] = import_module('.gui_utils.layout', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.gui_utils.list_picker'] = import_module('.gui_utils.list_picker', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.gui_utils.utils'] = import_module('.gui_utils.utils', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.gui_utils.widgets.label'] = import_module('.gui_utils.widgets.label', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.gui_utils.widgets.lcd'] = import_module('.gui_utils.widgets.lcd', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.gui_utils.widgets.push'] = import_module('.gui_utils.widgets.push', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.gui_utils.widgets.qled'] = import_module('.gui_utils.widgets.qled', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.gui_utils.widgets.spinbox'] = import_module('.gui_utils.widgets.spinbox', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.gui_utils.widgets.table'] = import_module('.gui_utils.widgets.table', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.h5modules'] = import_module('.h5modules', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.managers.action_manager'] = import_module('.managers.action_manager', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.managers.batchscan_manager'] = import_module('.managers.batchscan_manager', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.managers.modules_manager'] = import_module('.managers.modules_manager', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.managers.overshoot_manager'] = import_module('.managers.overshoot_manager', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.managers.parameter_manager'] = import_module('.managers.parameter_manager', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.managers.preset_manager'] = import_module('.managers.preset_manager', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.managers.preset_manager_utils'] = import_module('.managers.preset_manager_utils', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.managers.remote_manager'] = import_module('.managers.remote_manager', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.managers.roi_manager'] = import_module('.managers.roi_manager', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.math_utils'] = import_module('.math_utils', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.messenger'] = import_module('.messenger', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.ioxml'] = import_module('.parameter.ioxml', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.pymodaq_ptypes.bool'] = import_module('.parameter.pymodaq_ptypes.bool', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.pymodaq_ptypes.date'] = import_module('.parameter.pymodaq_ptypes.date', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.pymodaq_ptypes.filedir'] = import_module('.parameter.pymodaq_ptypes.filedir', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.pymodaq_ptypes.itemselect'] = import_module('.parameter.pymodaq_ptypes.itemselect', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.pymodaq_ptypes.led'] = import_module('.parameter.pymodaq_ptypes.led', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.pymodaq_ptypes.list'] = import_module('.parameter.pymodaq_ptypes.list', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.pymodaq_ptypes.numeric'] = import_module('.parameter.pymodaq_ptypes.numeric', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.pymodaq_ptypes.pixmap'] = import_module('.parameter.pymodaq_ptypes.pixmap', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.pymodaq_ptypes.slide'] = import_module('.parameter.pymodaq_ptypes.slide', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.pymodaq_ptypes.table'] = import_module('.parameter.pymodaq_ptypes.table', 'pymodaq.utils')
+# import_module('.parameter.pymodaq_ptypes.tableview', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.pymodaq_ptypes.tableview'] = import_module('.parameter.pymodaq_ptypes.tableview', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.pymodaq_ptypes.text'] = import_module('.parameter.pymodaq_ptypes.text', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.parameter.utils'] = import_module('.parameter.utils', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.data_viewers.viewer0D'] = import_module('.plotting.data_viewers.viewer0D', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.data_viewers.viewer1D'] = import_module('.plotting.data_viewers.viewer1D', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.data_viewers.viewer1Dbasic'] = import_module('.plotting.data_viewers.viewer1Dbasic', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.data_viewers.viewer2D'] = import_module('.plotting.data_viewers.viewer2D', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.data_viewers.viewer2D_basic'] = import_module('.plotting.data_viewers.viewer2D_basic', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.data_viewers.viewerbase'] = import_module('.plotting.data_viewers.viewer', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.data_viewers.viewerND'] = import_module('.plotting.data_viewers.viewerND', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.image_viewer'] = import_module('.plotting.image_viewer', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.items.axis_scaled'] = import_module('.plotting.items.axis_scaled', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.items.crosshair'] = import_module('.plotting.items.crosshair', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.items.image'] = import_module('.plotting.items.image', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.navigator'] = import_module('.plotting.navigator', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.scan_selector'] = import_module('.plotting.scan_selector', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.utils.filter'] = import_module('.plotting.utils.filter', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.utils.plot_utils'] = import_module('.plotting.utils.plot_utils', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.plotting.utils.signalND'] = import_module('.plotting.utils.signalND', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.qvariant'] = import_module('.qvariant', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.scanner'] = import_module('.scanner', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.tcp_server_client'] = import_module('.tcp_server_client', 'pymodaq.utils')
+# sys.modules['pymodaq.daq_utils.tree_layout.tree_layout_main'] = import_module('.tree_layout.tree_layout_main', 'pymodaq.utils')

pymodaq/dashboard.py

@@ -4,42 +4,41 @@
 import sys
 import datetime
 import subprocess
-import pickle
 import logging
 from pathlib import Path
 from importlib import import_module
 from packaging import version as version_mod
 from pyqtgraph.parametertree import Parameter, ParameterTree
 from qtpy import QtGui, QtWidgets, QtCore
-from qtpy.QtCore import Qt, QObject, Slot, QThread, Signal, QLocale
+from qtpy.QtCore import Qt, QObject, Slot, QThread, Signal
 from time import perf_counter
+import numpy as np
+
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils.gui_utils import DockArea, Dock, select_file
+import pymodaq.utils.gui_utils.layout as layout_mod
+from pymodaq.utils.messenger import messagebox
+from pymodaq.utils.parameter import utils as putils
+from pymodaq.utils import daq_utils as utils
+from pymodaq.utils.managers.modules_manager import ModulesManager
+from pymodaq.utils.daq_utils import get_version
+from pymodaq.utils.managers.preset_manager import PresetManager
+from pymodaq.utils.managers.overshoot_manager import OvershootManager
+from pymodaq.utils.managers.remote_manager import RemoteManager
+from pymodaq.utils.managers.roi_manager import ROISaver
+from pymodaq.utils.exceptions import DetectorError, ActuatorError
+from pymodaq.utils import config as configmod
+
+from pymodaq.control_modules.daq_move import DAQ_Move
+from pymodaq.control_modules.daq_viewer import DAQ_Viewer
+
+from pymodaq import extensions as extmod
 
-from pymodaq.daq_utils.gui_utils import DockArea, Dock, select_file
-import pymodaq.daq_utils.gui_utils.layout as layout_mod
-from pymodaq.daq_utils.messenger import messagebox
-from pymodaq.daq_utils.parameter import utils as putils
-import pymodaq.daq_utils.parameter.pymodaq_ptypes as ptypes  # to be placed after importing Parameter
-from pymodaq.daq_utils import daq_utils as utils
-from pymodaq.daq_utils.managers.modules_manager import ModulesManager
-from pymodaq.daq_utils.daq_utils import get_version
-from pymodaq.daq_utils.managers.preset_manager import PresetManager
-from pymodaq.daq_utils.managers.overshoot_manager import OvershootManager
-from pymodaq.daq_utils.managers.remote_manager import RemoteManager
-from pymodaq.daq_utils.managers.roi_manager import ROISaver
-from pymodaq.daq_utils.exceptions import DetectorError, ActuatorError
-from pymodaq.daq_utils import config as configmod
-
-from pymodaq.daq_move.daq_move_main import DAQ_Move
-from pymodaq.daq_viewer.daq_viewer_main import DAQ_Viewer
-
-from pymodaq.daq_scan import DAQ_Scan
-from pymodaq.daq_logger import DAQ_Logger
-from pymodaq.pid.pid_controller import DAQ_PID
 from pymodaq_plugin_manager.manager import PluginManager
 from pymodaq_plugin_manager.validate import get_pypi_pymodaq
 
 
-logger = utils.set_logger(utils.get_module_name(__file__))
+logger = set_logger(get_module_name(__file__))
 
 config = configmod.Config()
 
@@ -52,7 +51,7 @@ overshoot_path = configmod.get_set_overshoot_path()
 roi_path = configmod.get_set_roi_path()
 remote_path = configmod.get_set_remote_path()
 
-extensions = utils.get_extensions()
+extensions = extmod.get_extensions()
 
 
 class DashBoard(QObject):
@@ -94,7 +93,7 @@ class DashBoard(QObject):
         self.splash_sc = QtWidgets.QSplashScreen(splash, Qt.WindowStaysOnTopHint)
         self.overshoot_manager = None
         self.preset_manager = None
-        self.roi_saver = None
+        self.roi_saver: ROISaver = None
 
         self.remote_timer = QtCore.QTimer()
         self.remote_manager = None
@@ -102,7 +101,7 @@ class DashBoard(QObject):
         self.joysticks = dict([])
         self.ispygame_init = False
 
-        self.modules_manager: ModulesManager = None
+        self.modules_manager = None
 
         self.overshoot = False
         self.preset_file = None
@@ -124,7 +123,6 @@ class DashBoard(QObject):
         self.extra_params = params
         self.preset_manager = PresetManager(path=self.preset_path, extra_params=params, param_options=param_options)
 
-    @Slot(str)
     def add_status(self, txt):
         """
             Add the QListWisgetItem initialized with txt informations to the User Interface logger_list and to the save_parameters.logger array.
@@ -171,18 +169,18 @@ class DashBoard(QObject):
             win = QtWidgets.QMainWindow()
         area = DockArea()
         win.setCentralWidget(area)
-        self.scan_module = DAQ_Scan(dockarea=area, dashboard=self)
-        self.extensions['DAQ_Scan'] = self.scan_module
+        self.scan_module = extmod.DAQScan(dockarea=area, dashboard=self)
+        self.extensions['DAQScan'] = self.scan_module
         self.scan_module.status_signal.connect(self.add_status)
         win.show()
         return self.scan_module
 
-    def load_log_module(self, win=None) -> DAQ_Logger:
+    def load_log_module(self, win=None):
         if win is None:
             win = QtWidgets.QMainWindow()
         area = DockArea()
         win.setCentralWidget(area)
-        self.log_module = DAQ_Logger(dockarea=area, dashboard=self)
+        self.log_module = extmod.DAQ_Logger(dockarea=area, dashboard=self)
         self.extensions['DAQ_Logger'] = self.log_module
         self.log_module.status_signal.connect(self.add_status)
         win.show()
@@ -196,12 +194,25 @@ class DashBoard(QObject):
         dockarea = DockArea()
         self.pid_window.setCentralWidget(dockarea)
         self.pid_window.setWindowTitle('PID Controller')
-        self.pid_module = DAQ_PID(dockarea=dockarea)
+        self.pid_module = extmod.DAQ_PID(dockarea=dockarea)
         self.pid_module.set_module_manager(self.detector_modules, self.actuators_modules)
         self.extensions['DAQ_PID'] = self.pid_module
         self.pid_window.show()
         return self.pid_module
 
+    def load_console(self):
+        dock_console = Dock('QTConsole')
+        self.dockarea.addDock(dock_console, 'bottom')
+        qtconsole = extmod.QtConsole(style_sheet=config('style', 'syntax_highlighting'),
+                                    syntax_style=config('style', 'syntax_highlighting'),
+                                    custom_banner=extmod.console.BANNER)
+        dock_console.addWidget(qtconsole)
+        self.extensions['qtconsole'] = qtconsole
+
+        qtconsole.push_variables(dict(dashboard=self, mods=self.modules_manager, np=np))
+
+        return qtconsole
+
     def load_extensions_module(self, ext):
         self.extension_windows.append(QtWidgets.QMainWindow())
         area = DockArea()
@@ -316,6 +327,8 @@ class DashBoard(QObject):
         action_log.triggered.connect(lambda: self.load_log_module())
         action_pid = self.actions_menu.addAction('PID module')
         action_pid.triggered.connect(lambda: self.load_pid_module())
+        action_console = self.actions_menu.addAction('IPython Console')
+        action_console.triggered.connect(lambda: self.load_console())
 
         extensions_actions = []
         for ext in extensions:
@@ -563,13 +576,13 @@ class DashBoard(QObject):
         move_forms.append(QtWidgets.QWidget())
         mov_mod_tmp = DAQ_Move(move_forms[-1], plug_name)
 
-        mov_mod_tmp.ui.Stage_type_combo.setCurrentText(plug_type)
-        mov_mod_tmp.ui.Quit_pb.setEnabled(False)
+        mov_mod_tmp.actuator = plug_type
         QtWidgets.QApplication.processEvents()
+        mov_mod_tmp.manage_ui_actions('quit', 'setEnabled', False)
 
         if plug_settings is not None:
             try:
-                utils.set_param_from_param(mov_mod_tmp.settings, plug_settings)
+                putils.set_param_from_param(mov_mod_tmp.settings, plug_settings)
             except KeyError as e:
                 mssg = f'Could not set this setting: {str(e)}\n' \
                        f'The Preset is no more compatible with the plugin {plug_type}'
@@ -581,6 +594,37 @@ class DashBoard(QObject):
         move_docks[-1].addWidget(move_forms[-1])
         actuators_modules.append(mov_mod_tmp)
 
+    def add_det(self, plug_name, plug_settings, det_docks_settings, det_docks_viewer, detector_modules):
+
+        plug_type = plug_settings.child('main_settings', 'DAQ_type').value()
+        plug_subtype = plug_settings.child('main_settings', 'detector_type').value()
+        det_docks_settings.append(Dock(plug_name + " settings", size=(150, 250)))
+        det_docks_viewer.append(Dock(plug_name + " viewer", size=(350, 350)))
+        if len(detector_modules) == 0:
+            self.logger_dock.area.addDock(det_docks_settings[-1], 'bottom')  # dockarea of the logger dock
+        else:
+            self.dockarea.addDock(det_docks_settings[-1], 'right',
+                                  detector_modules[-1].viewers_docks[-1])
+        self.dockarea.addDock(det_docks_viewer[-1], 'right', det_docks_settings[-1])
+        det_mod_tmp = DAQ_Viewer(self.dockarea, title=plug_name, daq_type=plug_type,
+                                 dock_settings=det_docks_settings[-1],
+                                 dock_viewer=det_docks_viewer[-1])
+        QtWidgets.QApplication.processEvents()
+        det_mod_tmp.detector = plug_subtype
+        QtWidgets.QApplication.processEvents()
+        det_mod_tmp.manage_ui_actions('quit', 'setEnabled', False)
+
+        if plug_settings is not None:
+            try:
+                putils.set_param_from_param(det_mod_tmp.settings, plug_settings)
+            except KeyError as e:
+                mssg = f'Could not set this setting: {str(e)}\n' \
+                       f'The Preset is no more compatible with the plugin {plug_subtype}'
+                logger.warning(mssg)
+                self.splash_sc.showMessage(mssg, color=Qt.white)
+
+        detector_modules.append(det_mod_tmp)
+
     def set_file_preset(self, filename):
         """
             Set a file managers from the converted xml file given by the filename parameter.
@@ -629,14 +673,14 @@ class DashBoard(QObject):
                         path.extend(preset_path)
                         self.pid_module.settings.child(*path).setValue(child.value())
 
-                    model_class = utils.get_models(
+                    model_class = extmod.get_models(
                         self.preset_manager.preset_params.child('pid_models').value())['class']
                     for setp in model_class.setpoints_names:
                         self.add_move(setp, None, 'PID', move_docks, move_forms, actuators_modules)
                         actuators_modules[-1].controller = dict(curr_point=self.pid_module.curr_points_signal,
                                                            setpoint=self.pid_module.setpoints_signal,
                                                            emit_curr_points=self.pid_module.emit_curr_points_sig)
-                        actuators_modules[-1].ui.IniStage_pb.click()
+                        actuators_modules[-1].init_hardware_ui()
                         QtWidgets.QApplication.processEvents()
                         self.poll_init(actuators_modules[-1])
                         QtWidgets.QApplication.processEvents()
@@ -689,13 +733,14 @@ class DashBoard(QObject):
                     if plugin['type'] == 'move':
                         try:
                             plug_type = plug_settings.child('main_settings', 'move_type').value()
-                            self.add_move(plug_name, plug_settings, plug_type, move_docks, move_forms, actuators_modules)
+                            self.add_move(plug_name, plug_settings, plug_type, move_docks, move_forms,
+                                          actuators_modules)
 
                             if ind_plugin == 0:  # should be a master type plugin
                                 if plugin['status'] != "Master":
                                     logger.error('error in the master/slave type for plugin {}'.format(plug_name))
                                 if plug_init:
-                                    actuators_modules[-1].ui.IniStage_pb.click()
+                                    actuators_modules[-1].init_hardware_ui()
                                     QtWidgets.QApplication.processEvents()
                                     self.poll_init(actuators_modules[-1])
                                     QtWidgets.QApplication.processEvents()
@@ -705,7 +750,7 @@ class DashBoard(QObject):
                                     logger.error('error in the master/slave type for plugin {}'.format(plug_name))
                                 if plug_init:
                                     actuators_modules[-1].controller = master_controller
-                                    actuators_modules[-1].ui.IniStage_pb.click()
+                                    actuators_modules[-1].init_hardware_ui()
                                     QtWidgets.QApplication.processEvents()
                                     self.poll_init(actuators_modules[-1])
                                     QtWidgets.QApplication.processEvents()
@@ -718,32 +763,8 @@ class DashBoard(QObject):
                     else:
                         try:
                             ind_det += 1
-                            plug_type = plug_settings.child('main_settings', 'DAQ_type').value()
-                            plug_subtype = plug_settings.child('main_settings', 'detector_type').value()
-
-                            det_docks_settings.append(Dock(plug_name + " settings", size=(150, 250)))
-                            det_docks_viewer.append(Dock(plug_name + " viewer", size=(350, 350)))
-                            if ind_det == 0:
-                                self.logger_dock.area.addDock(det_docks_settings[-1],
-                                                              'bottom')  # dockarea of the logger dock
-                            else:
-                                self.dockarea.addDock(det_docks_settings[-1], 'right', det_docks_viewer[-2])
-                            self.dockarea.addDock(det_docks_viewer[-1], 'right', det_docks_settings[-1])
-                            det_mod_tmp = DAQ_Viewer(self.dockarea, dock_settings=det_docks_settings[-1],
-                                                     dock_viewer=det_docks_viewer[-1], title=plug_name,
-                                                     DAQ_type=plug_type, parent_scan=self)
-                            det_mod_tmp.detector = plug_subtype
-                            det_mod_tmp.ui.Quit_pb.setEnabled(False)
-                            detector_modules.append(det_mod_tmp)
-
-                            try:
-                                utils.set_param_from_param(det_mod_tmp.settings, plug_settings)
-                            except KeyError as e:
-                                mssg = f'Could not set this setting: {str(e)}\n'\
-                                       f'The Preset is no more compatible with the plugin {plug_subtype}'
-                                logger.warning(mssg)
-                                self.splash_sc.showMessage(mssg, color=Qt.white)
-
+                            self.add_det(plug_name, plug_settings, det_docks_settings, det_docks_viewer,
+                                         detector_modules)
                             QtWidgets.QApplication.processEvents()
 
                             try:
@@ -751,7 +772,7 @@ class DashBoard(QObject):
                                     if plugin['status'] != "Master":
                                         logger.error('error in the master/slave type for plugin {}'.format(plug_name))
                                     if plug_init:
-                                        detector_modules[-1].ui.IniDet_pb.click()
+                                        detector_modules[-1].init_hardware()
                                         QtWidgets.QApplication.processEvents()
                                         self.poll_init(detector_modules[-1])
                                         QtWidgets.QApplication.processEvents()
@@ -761,7 +782,7 @@ class DashBoard(QObject):
                                         logger.error('error in the master/slave type for plugin {}'.format(plug_name))
                                     if plug_init:
                                         detector_modules[-1].controller = master_controller
-                                        detector_modules[-1].ui.IniDet_pb.click()
+                                        detector_modules[-1].init_hardware()
                                         QtWidgets.QApplication.processEvents()
                                         self.poll_init(detector_modules[-1])
                                         QtWidgets.QApplication.processEvents()
@@ -1086,10 +1107,8 @@ class DashBoard(QObject):
 
                 # connecting to logger
                 for mov in actuators_modules:
-                    mov.status_signal[str].connect(self.add_status)
                     mov.init_signal.connect(self.update_init_tree)
                 for det in detector_modules:
-                    det.status_signal[str].connect(self.add_status)
                     det.init_signal.connect(self.update_init_tree)
 
                 self.splash_sc.close()
@@ -1352,7 +1371,7 @@ def main(init_qt=True):
     # win.setVisible(False)
     prog = DashBoard(area)
     if init_qt:
-        sys.exit(app.exec_())
+        sys.exit(app.exec())
     return prog, win
 
 

pymodaq/examples/custom_app.py

@@ -1,24 +1,25 @@
 from collections import OrderedDict
 import datetime
 import numpy as np
-from pymodaq.daq_utils.gui_utils.custom_app import CustomApp
-from pymodaq.daq_utils.gui_utils.dock import DockArea, Dock
-from  pymodaq.daq_utils.gui_utils.file_io import select_file
-from pymodaq.daq_utils.config import Config
+
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils.gui_utils.custom_app import CustomApp
+from pymodaq.utils.gui_utils.dock import DockArea, Dock
+from  pymodaq.utils.gui_utils.file_io import select_file
+from pymodaq.utils.config import Config
 
 from qtpy import QtWidgets
 from qtpy.QtCore import Slot, QDate, QThread
 
-from pymodaq.daq_utils import gui_utils as gutils
-from pymodaq.daq_utils import daq_utils as utils
-from pymodaq.daq_utils.parameter import ioxml
-from pymodaq.daq_viewer.daq_viewer_main import DAQ_Viewer
-from pymodaq.daq_utils.plotting.data_viewers.viewer0D import Viewer0D
+from pymodaq.utils import daq_utils as utils
+from pymodaq.utils.parameter import ioxml
+from pymodaq.control_modules.daq_viewer import DAQ_Viewer
+from pymodaq.utils.plotting.data_viewers.viewer0D import Viewer0D
 
-from pymodaq.daq_utils.h5modules import H5Browser, H5Saver
+from pymodaq.utils.h5modules import H5Browser, H5Saver
 
 config = Config()
-logger = utils.set_logger(utils.get_module_name(__file__))
+logger = set_logger(get_module_name(__file__))
 
 
 class CustomAppExample(CustomApp):

pymodaq/examples/custom_viewer.py

@@ -1,11 +1,11 @@
-from pymodaq.daq_utils.gui_utils.widgets.table import SpinBoxDelegate
-from  pymodaq.daq_utils.parameter.utils import get_widget_from_tree
-from pymodaq.daq_utils.plotting.data_viewers.viewer2D import Viewer2D
-from pymodaq.daq_utils import gui_utils as gutils
+from pymodaq.utils.gui_utils.widgets.table import SpinBoxDelegate
+from  pymodaq.utils.parameter.utils import get_widget_from_tree
+from pymodaq.utils.plotting.data_viewers.viewer2D import Viewer2D
+from pymodaq.utils import gui_utils as gutils
 from pyqtgraph.dockarea import Dock
 from pyqtgraph.parametertree import ParameterTree, Parameter
-from pymodaq.daq_utils.parameter.pymodaq_ptypes.tableview import TableViewCustom
-from pymodaq.daq_utils.scanner import TableModelTabular
+from pymodaq.utils.parameter.pymodaq_ptypes.tableview import TableViewCustom
+from pymodaq.utils.scanner import TableModelTabular
 from qtpy.QtCore import QObject, Qt, Slot
 from qtpy import QtWidgets
 
@@ -58,7 +58,7 @@ class ViewerPointList(QObject):
         self.table_view = get_widget_from_tree(self.settings_tree, TableViewCustom)[0]
         self.settings.child(('tabular_table')).setValue(self.table_model)
 
-        self.table_view.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.ResizeToContents)
+        self.table_view.horizontalHeader().setResizeMode(QtWidgets.QHeaderView.ResizeToContents)
         self.table_view.horizontalHeader().setStretchLastSection(True)
         self.table_view.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
         self.table_view.setSelectionMode(QtWidgets.QTableView.SingleSelection)
@@ -81,8 +81,8 @@ class ViewerPointList(QObject):
 
 
 if __name__ == '__main__':
-    from pymodaq.daq_utils.gui_utils import DockArea
-    from pymodaq.daq_utils.daq_utils import Axis
+    from pymodaq.utils.gui_utils import DockArea
+    from pymodaq.utils.data import Axis
     import sys
     import numpy as np
 
@@ -96,7 +96,7 @@ if __name__ == '__main__':
     Ny = 200
     x = (np.linspace(0, Nx - 1, Nx) + 100) / 2
     y = (np.linspace(0, Ny - 1, Ny) - 10) * 2
-    from pymodaq.daq_utils.daq_utils import gauss2D
+    from pymodaq.utils.daq_utils import gauss2D
 
     data_red = 3 * gauss2D(x, np.mean(x), (np.max(x)-np.min(x)) / 5, y, np.mean(y), (np.max(y)-np.min(y)) / 5, 1)
     data_red += np.random.random(data_red.shape)

pymodaq/examples/function_plotter.py

@@ -9,20 +9,22 @@ import numpy as np
 from qtpy import QtWidgets
 from qtpy.QtCore import Slot, QDate, QThread, QTimer
 
-from pymodaq.daq_utils.gui_utils.custom_app import CustomApp
-from pymodaq.daq_utils.gui_utils.dock import DockArea, Dock
-from pymodaq.daq_utils.gui_utils.file_io import select_file
-from pymodaq.daq_utils.config import Config
+from pymodaq.utils import data as data_mod
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils.gui_utils.custom_app import CustomApp
+from pymodaq.utils.gui_utils.dock import DockArea, Dock
+from pymodaq.utils.gui_utils.file_io import select_file
+from pymodaq.utils.config import Config
 
-from pymodaq.daq_utils import gui_utils as gutils
-from pymodaq.daq_utils import daq_utils as utils
+from pymodaq.utils import gui_utils as gutils
+from pymodaq.utils import daq_utils as utils
 
-from pymodaq.daq_utils.parameter import ioxml
-from pymodaq.daq_utils.plotting.data_viewers.viewer1D import Viewer1D
-from pymodaq.daq_utils.h5modules import H5Browser, H5Saver
+from pymodaq.utils.parameter import ioxml
+from pymodaq.utils.plotting.data_viewers.viewer1D import Viewer1D
+from pymodaq.utils.h5modules import H5Browser, H5Saver
 
 config = Config()
-logger = utils.set_logger(utils.get_module_name(__file__))
+logger = set_logger(get_module_name(__file__))
 
 
 class FunctionPlotter(CustomApp):
@@ -34,7 +36,8 @@ class FunctionPlotter(CustomApp):
             {'title': 'File name:', 'name': 'target_filename', 'type': 'str', 'value': "", 'readonly': True},
             {'title': 'Date:', 'name': 'date', 'type': 'date', 'value': QDate.currentDate()},
 
-            {'title': 'Functions:', 'name': 'functions', 'type': 'list', 'values': ['exp(-(x/5)**2)', 'sin(x)', 'arctan(x)']},
+            {'title': 'Functions:', 'name': 'functions', 'type': 'list',
+             'limits': ['exp(-(x/5)**2)', 'sin(x)', 'arctan(x)']},
             {'title': 'Function:', 'name': 'function', 'type': 'str', 'value': 'sinc(x)'},
             {'title': 'Add function:', 'label': 'Add!', 'name': 'add_function', 'type': 'bool_push', 'value': False},
             {'title': 'Plot refresh (ms):', 'name': 'plot_refresh', 'type': 'int', 'value': 2000},
@@ -110,8 +113,8 @@ class FunctionPlotter(CustomApp):
 
         function_vals = eval(f'np.{function_str}')
 
-        self.viewer.show_data([function_vals], labels=[function_str], x_axis=utils.Axis(x, label='An axis',
-                                                                                        units='arb. units'))
+        self.viewer.show_data([function_vals], labels=[function_str], x_axis=data_mod.Axis(x, label='An axis',
+                                                                                             units='arb. units'))
 
     def value_changed(self, param):
         if param.name() == 'add_function':

pymodaq/examples/nonlinearscanner.py

@@ -1,17 +1,19 @@
 
 import numpy as np
-from pymodaq.daq_utils.gui_utils.custom_app import CustomApp
-from pymodaq.daq_utils.gui_utils.dock import DockArea, Dock
-from pymodaq.daq_utils.config import Config, get_set_preset_path
+
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils.gui_utils.custom_app import CustomApp
+from pymodaq.utils.gui_utils.dock import DockArea, Dock
+from pymodaq.utils.config import Config, get_set_preset_path
 from qtpy import QtWidgets
 from qtpy.QtCore import Signal, QLocale
 
-from pymodaq.daq_utils import gui_utils as gutils
-from pymodaq.daq_utils import daq_utils as utils
+from pymodaq.utils import gui_utils as gutils
+from pymodaq.utils import daq_utils as utils
 
 
 config = Config()
-logger = utils.set_logger(utils.get_module_name(__file__))
+logger = set_logger(get_module_name(__file__))
 
 
 class NonLinearScanner(CustomApp):

pymodaq/examples/parameter_ex.py

@@ -4,12 +4,12 @@ Examples of custome parameter types derived from pyqtgraph
 """
 import sys
 
-import pymodaq.daq_utils.gui_utils.widgets.table
+import pymodaq.utils.gui_utils.widgets.table
 from qtpy import QtWidgets, QtCore
 from pyqtgraph.parametertree import Parameter, ParameterTree
 from collections import OrderedDict
-from pymodaq.daq_utils import gui_utils as gutils
-from pymodaq.daq_utils.parameter import pymodaq_ptypes
+from pymodaq.utils import gui_utils as gutils
+from pymodaq.utils.parameter import pymodaq_ptypes
 from pymodaq.resources.QtDesigner_Ressources import QtDesigner_ressources_rc
 
 
@@ -80,13 +80,13 @@ class ParameterEx:
             {'title': 'Table widget', 'name': 'tablewidget', 'type': 'table', 'value':
                 OrderedDict(key1='data1', key2=24), 'header': ['keys', 'limits'], 'height': 100},
             {'title': 'Table view', 'name': 'tabular_table', 'type': 'table_view',
-             'delegate': pymodaq.daq_utils.gui_utils.widgets.table.SpinBoxDelegate, 'menu': True,
-             'value': pymodaq.daq_utils.gui_utils.widgets.table.TableModel([[0.1, 0.2, 0.3]], ['value1', 'value2', 'value3']),
+             'delegate': pymodaq.utils.gui_utils.widgets.table.SpinBoxDelegate, 'menu': True,
+             'value': pymodaq.utils.gui_utils.widgets.table.TableModel([[0.1, 0.2, 0.3]], ['value1', 'value2', 'value3']),
              'tip': 'The advantage of the Table model lies in its modularity.\n For concrete examples see the'
                     'TableModelTabular and the TableModelSequential custom models in the'
-                    ' pymodaq.daq_utils.scanner module'},
+                    ' pymodaq.utils.scanner module'},
         ]},  # The advantage of the Table model lies in its modularity for concrete examples see the
-        # TableModelTabular and the TableModelSequential custom models in the pymodaq.daq_utils.scanner module
+        # TableModelTabular and the TableModelSequential custom models in the pymodaq.utils.scanner module
     ]
 
     def __init__(self, tree):