pymodaq 5.0.0__py3-none-any.whl → 5.0.2__py3-none-any.whl

pymodaq/extensions/pid/pid_controller.py

@@ -1,5 +1,7 @@
 import time
 from functools import partial  # needed for the button to sync setpoint with currpoint
+from typing import Dict, List, TYPE_CHECKING
+
 import numpy as np
 
 from qtpy import QtGui, QtWidgets
@@ -9,13 +11,14 @@ from simple_pid import PID
 
 from pymodaq_utils.logger import set_logger, get_module_name
 from pymodaq_utils.utils import ThreadCommand, find_dict_in_list_from_key_val
+from pymodaq.utils.exceptions import DetectorError, ActuatorError, PIDError
 
 from pymodaq_gui.parameter import utils as putils
 from pymodaq_gui.parameter import Parameter, ParameterTree
 from pymodaq_gui.plotting.data_viewers.viewer0D import Viewer0D
 from pymodaq_gui.utils.widgets import QLED, LabelWithFont, SpinBox
 from pymodaq_gui.utils.dock import DockArea, Dock
-from pymodaq_gui.utils.custom_app import CustomApp
+
 
 from pymodaq_data.data import DataToExport, DataCalculated, DataRaw
 from pymodaq_utils.config import Config
@@ -23,6 +26,11 @@ from pymodaq_utils.config import Config
 from pymodaq.utils.managers.modules_manager import ModulesManager
 from pymodaq.extensions.pid.utils import get_models
 from pymodaq.utils.data import DataActuator, DataToActuators
+from pymodaq.extensions.pid.actuator_controller import PIDController
+from pymodaq.extensions.utils import CustomExt
+
+if TYPE_CHECKING:
+    from pymodaq.control_modules.daq_move import DAQ_Move
 
 
 config = Config()
@@ -38,7 +46,7 @@ def convert_output_limits(lim_min=-10., min_status=False, lim_max=10., max_statu
     return output
 
 
-class DAQ_PID(CustomApp):
+class DAQ_PID(CustomExt):
     """
     """
     command_pid = Signal(ThreadCommand)
@@ -158,7 +166,7 @@ class DAQ_PID(CustomApp):
     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)
 
@@ -170,7 +178,7 @@ class DAQ_PID(CustomApp):
         self.set_action_enabled('run', enable)
         self.set_action_enabled('pause', enable)
 
-    def setup_menu(self):
+    def setup_menu(self, menubar: QtWidgets.QMenuBar = None):
         '''
         to be subclassed
         create menu for actions contained into the self.actions_manager, for instance:
@@ -241,6 +249,7 @@ class DAQ_PID(CustomApp):
         logger.debug('connecting actions and other')
         self.connect_action('quit', self.quit_fun, )
         self.connect_action('ini_model', self.ini_model)
+        self.connect_action('create_setp_actuators', self.create_setp_actuators)
         self.connect_action('ini_pid', self.ini_PID)
         self.connect_action('run', self.run_PID)
         self.connect_action('pause', self.pause_PID)
@@ -252,12 +261,21 @@ class DAQ_PID(CustomApp):
         self.add_widget('model_label', QtWidgets.QLabel, 'Init Model:')
         self.add_action('ini_model', 'Init Model', 'ini', tip='Initialize the selected model: algo/data conversion')
         self.add_widget('model_led', QLED, toolbar=self.toolbar)
+
+        self.add_action('create_setp_actuators', 'Create SetPoint Actuators', 'Add_Step',
+                        tip='Create a DAQ_Move Control Module for each SetPoint allowing to'
+                            'control them from the DashBoard, therefore within other extensions')
+
         self.add_widget('model_label', QtWidgets.QLabel, 'Init PID Runner:')
-        self.add_action('ini_pid', 'Init the PID loop', 'ini', tip='Init the PID thread', checkable=True)
+        self.add_action('ini_pid', 'Init the PID loop', 'ini', tip='Init the PID thread',
+                        checkable=True)
         self.add_widget('pid_led', QLED, toolbar=self.toolbar)
-        self.add_action('run', 'Run The PID loop', 'run2', tip='run or stop the pid loop', checkable=True)
-        self.add_action('pause', 'Pause the PID loop', 'pause', tip='Pause the PID loop', checkable=True)
+        self.add_action('run', 'Run The PID loop', 'run2', tip='run or stop the pid loop',
+                        checkable=True)
+        self.add_action('pause', 'Pause the PID loop', 'pause', tip='Pause the PID loop',
+                        checkable=True)
         self.set_action_checked('pause', True)
+        self.set_action_enabled('create_setp_actuators', False)
         logger.debug('actions set')
 
     def setup_docks(self):
@@ -297,6 +315,17 @@ class DAQ_PID(CustomApp):
 
         self.dock_pid.addWidget(widget)
 
+    def create_setp_actuators(self):
+        # Now that we have the module manager, load PID if it is checked in managers
+        try:
+            for setp in self.model_class.setpoints_names:
+                self.dashboard.add_move_from_extension(setp, 'PID', PIDController(self))
+            self.set_action_enabled('create_setp_actuators', False)
+
+        except Exception as e:
+            raise PIDError('Could not load the PID extension and create setpoints actuators'
+                           f'{str(e)}')
+
     def get_set_model_params(self, model_name):
         self.settings.child('models', 'model_params').clearChildren()
         models = get_models()
@@ -355,6 +384,7 @@ class DAQ_PID(CustomApp):
             self.enable_controls_pid(True)
             self.get_action('model_led').set_as_true()
             self.set_action_enabled('ini_model', False)
+            self.set_action_enabled('create_setp_actuators', True)
 
         except Exception as e:
             logger.exception(str(e))
@@ -368,10 +398,10 @@ class DAQ_PID(CustomApp):
         for ind, sp in enumerate(self.setpoints_sb):
             sp.setValue(values[ind])
 
-    def setpoints_external(self, values_dict):
+    def setpoints_external(self, values_dict: Dict[str, DataActuator]):
         for key in values_dict:
             index = self.model_class.setpoints_names.index(key)
-            self.setpoints_sb[index].setValue(values_dict[key])
+            self.setpoints_sb[index].setValue(values_dict[key].value())
 
     @property
     def curr_points(self):
@@ -643,38 +673,16 @@ class PIDRunner(QObject):
 
 
 if __name__ == '__main__':
-    import sys
-    from pathlib import Path
-    from pymodaq.utils.daq_utils import get_set_preset_path
-
-    app = QtWidgets.QApplication(sys.argv)
-    if config['style']['darkstyle']:
-        import qdarkstyle
-        app.setStyleSheet(qdarkstyle.load_stylesheet())
-
-    from pymodaq.dashboard import DashBoard
-
-    win = QtWidgets.QMainWindow()
-    area = DockArea()
-    win.setCentralWidget(area)
-    win.resize(1000, 500)
-    win.setWindowTitle('PyMoDAQ Dashboard')
-
-    dashboard = DashBoard(area)
-    pid = None
-    file = Path(get_set_preset_path()).joinpath(f"{config('presets', 'default_preset_for_pid')}.xml")
-    if file.exists():
-        dashboard.set_preset_mode(file)
-        pid = dashboard.load_pid_module()
-    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()
-
-    sys.exit(app.exec_())
+    from pymodaq_gui.utils.utils import mkQApp
+    from pymodaq.utils.gui_utils.loader_utils import load_dashboard_with_preset
+
+    app = mkQApp('DAQ_PID')
+    preset_file_name = config('presets', f'default_preset_for_pid')
+
+    dashboard, extension, win = load_dashboard_with_preset(preset_file_name, 'DAQ_PID')
+
+    app.exec()
+
 
 
 

pymodaq/extensions/pid/utils.py

@@ -27,6 +27,7 @@ DAQ_2DViewer_Det_types = get_plugins('daq_2Dviewer')
 DAQ_NDViewer_Det_types = get_plugins('daq_NDviewer')
 
 
+
 class DataToActuatorPID(DataToActuators):
 
     def __init__(self, *args, **kwargs):
@@ -136,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_())
 
 
@@ -179,10 +156,9 @@ 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 = get_entrypoints(group='pymodaq.pid_models')
-    discovered_models = get_entrypoints(group='pymodaq.models')
+    discovered_models = list(get_entrypoints(group='pymodaq.pid_models'))
+    discovered_models.extend(list(get_entrypoints(group='pymodaq.models')))
     if len(discovered_models) > 0:
         for pkg in discovered_models:
             try:

pymodaq/extensions/utils.py

@@ -8,14 +8,22 @@ import importlib
 from pathlib import Path
 import pkgutil
 import warnings
+from typing import Union, TYPE_CHECKING
 
-from pymodaq_utils.utils import get_entrypoints
+from qtpy import QtCore, QtWidgets
 
+from pymodaq_gui.utils.dock import DockArea
+from pymodaq_utils.utils import get_entrypoints
 from pymodaq_utils import logger as logger_module
+from pymodaq_gui.utils.custom_app import CustomApp
 
+from pymodaq.utils.managers.modules_manager import ModulesManager
 
 logger = logger_module.set_logger(logger_module.get_module_name(__file__))
 
+if TYPE_CHECKING:
+    from pymodaq.dashboard import DashBoard
+
 
 def get_ext_modules(path: Path):
     modules = []
@@ -47,13 +55,39 @@ def get_extensions():
                 module = importlib.import_module(pkg.value)
                 modules = get_ext_modules(Path(module.__path__[0]).joinpath('extensions'))
                 for mod in modules:
-                    mod_in = importlib.import_module(f'{pkg.value}.extensions.{mod}')
-                    if hasattr(mod_in, 'EXTENSION_NAME'):
-                        extension_import.append({'pkg': pkg.value, 'module': mod, 'name': mod_in.EXTENSION_NAME,
-                                                 'class_name': mod_in.CLASS_NAME})
+                    try:
+                        mod_in = importlib.import_module(f'{pkg.value}.extensions.{mod}')
+                        if hasattr(mod_in, 'EXTENSION_NAME'):
+                            extension_import.append({'pkg': pkg.value, 'module': mod,
+                                                     'name': mod_in.EXTENSION_NAME,
+                                                     'class_name': mod_in.CLASS_NAME})
 
-            except Exception as e:  # pragma: no cover
-                logger.warning(f'Impossible to import the {pkg.value}.extensions.{mod} extension: {str(e)}')
+                    except Exception as e:  # pragma: no cover
+                        logger.warning(f'Impossible to import the {pkg.value}.extensions.{mod} extension: '
+                                       f'{str(e)}')
+            except Exception as e:
+                logger.warning(f'Impossible to import the {pkg.value} package: '
+                               f'{str(e)}')
 
     return extension_import
 
+
+class CustomExt(CustomApp):
+
+    def __init__(self, parent: Union[DockArea, QtWidgets.QWidget], dashboard: 'DashBoard'):
+        super().__init__(parent)
+
+        self.dashboard = dashboard
+
+    @property
+    def modules_manager(self) -> ModulesManager:
+        """useful tool to interact with DAQ_Moves and DAQ_Viewers
+
+        Will be available if a DashBoard has been set
+
+        Returns
+        -------
+        ModulesManager
+        """
+        if self.dashboard is not None:
+            return self.dashboard.modules_manager

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/resources/setup_plugin.py

@@ -23,6 +23,7 @@ def setup(path: Path):
         name=PLUGIN_NAME,
         description=config['plugin-info']['description'],
         long_description=long_description,
+        long_description_content_type='text/x-rst',
         license=config['plugin-info']['license'],
         url=config['plugin-info']['package-url'],
         author=config['plugin-info']['author'],

pymodaq/updater.py

@@ -0,0 +1,107 @@
+import argparse
+import subprocess
+import sys
+import time
+import logging
+
+from pathlib import Path
+
+from pymodaq_utils.logger import set_logger, get_module_name
+
+logger = set_logger(get_module_name(__file__))
+logger.addHandler(logging.StreamHandler(sys.stdout))
+
+def wait_for_parent():
+	'''
+		A function to wait for its parent to terminate execution.
+
+		In order to achieve that, this process has to be started with
+		stdin replaced by a piped stream from its parent. When the
+		parent terminates, stdin will close and either return from read
+		or throw an exception. De facto creating a way to wait for its
+		parent's termination.
+
+		It then sleep for 2 seconds, to let the parent process complete
+		termination.
+
+		CAUTION: If the process was not started by piping stdin AND 
+		the --wait option is set, this function will hang forever.
+
+		We could use `psutil` or a similar lib to check for parent's process
+		existance with its pid. 
+	'''
+
+	logger.info("Waiting for parent process to stop.")
+	try:
+		sys.stdin.read()
+	except:
+		pass
+	logger.debug("Parent process closed stdin")
+	time.sleep(2)
+	logger.info("Parent process stopped.")
+
+def process_args():
+	'''
+		Declare arguments for updater.py, parse them and returns them in an object.
+		The arguments are:
+			--file <file> to request a python program to (re)start after update if needed (optional) 
+			--wait        to wait for the starting process to terminate before updating (optional, defaults to False)
+			packages      the package list to install/update (they should contain the version in a pip accepted format)
+	'''
+	parser = argparse.ArgumentParser(description='Update pymodaq using pip.')
+	parser.add_argument('--file', type=str,  help='the pymodaq script to restart after update')
+	parser.add_argument("--wait", action="store_true", help="enable waiting for pymodaq to finish mode (default is disabled).")
+	parser.add_argument('packages', type=str, nargs='+', help='package list')
+	return parser.parse_args()
+
+def restart_if_command_launch(args):
+	'''
+		Try to detect if this process if launched using the declared command (i.e. `pymodaq_updater`)
+		or using the script file (`updater.py`). If it uses the command, it restart the process to
+		force it to use the script file, thus preventing a locked file during update on windows systems.
+	'''
+	python_file_path = Path(__file__) # Should be the path to `updater.py`
+	started_path = Path(sys.argv[0])  # Either `updater.py` or `pymodaq_updater`
+	
+	# If they're different we'll restart using the script file
+	if started_path.absolute() != python_file_path.absolute():
+		logger.info("Started as pymodaq_updater, need to restart using python to prevent lock.")
+		# We HAVE to wait for this process to stop in the restarted process
+		new_args = ['--wait'] + sys.argv[1:]
+		if args.wait:
+			wait_for_parent()
+	
+		subprocess.Popen([sys.executable, str(python_file_path.absolute())] + new_args,  stdin=subprocess.PIPE)
+		sys.exit(0)
+
+def main():
+	args = process_args()
+	logger.info(f"Arguments processed: {args}")
+
+	restart_if_command_launch(args)
+
+	if args.wait:
+		wait_for_parent()
+
+	packages_str = ', '.join(args.packages)
+	logger.info(f'Updating packages: {packages_str}')
+	
+	with subprocess.Popen([sys.executable, '-m', 'pip', 'install'] + args.packages, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) as pip:
+		for line in pip.stdout:
+			# Can't decode as some characters are not valid and make the whole process fail
+			logger.info(line[:-1])
+	ret_code = pip.wait()
+	
+
+	if ret_code == 0:
+		logger.info(f'Succesfully updated {packages_str}')
+	else:
+		logger.error(f'Error while updating {packages_str}, pip returned {ret_code}')
+
+	if args.file is not None:
+		logger.info(f"Restarting {args.file} script after update.")
+		subprocess.Popen([sys.executable, args.file])
+
+
+if __name__ == "__main__":
+	main()

pymodaq/utils/chrono_timer.py

@@ -6,8 +6,7 @@ from qtpy import QtGui, QtWidgets
 from qtpy.QtCore import Qt, QObject, QTimer
 
 
-from pymodaq_gui.utils import DockArea, Dock
-from pymodaq_gui.QtDesigner_Ressources import QtDesigner_ressources_rc
+from pymodaq_gui.utils.dock import DockArea, Dock
 
 
 class PushButtonShortcut(QtWidgets.QPushButton):
@@ -64,7 +63,7 @@ class ChronoTimer(QObject):
 
         self.dock_chrono_timer.setAutoFillBackground(True)
         palette = self.dock_chrono_timer.palette()
-        palette.setColor(palette.Background, QtGui.QColor(0, 0, 0))
+        palette.setColor(palette.Window, QtGui.QColor(0, 0, 0))
         self.dock_chrono_timer.setPalette(palette)
 
         self.time_lcd = QtWidgets.QLCDNumber(8)
@@ -92,7 +91,7 @@ class ChronoTimer(QObject):
         self.controls_layout.addWidget(hor_widget)
 
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/run2.png"), QtGui.QIcon.Normal,
+        icon.addPixmap(QtGui.QPixmap("icons:run2.png"), QtGui.QIcon.Normal,
                        QtGui.QIcon.Off)
         self.start_pb = PushButtonShortcut(icon, 'Start',
                                            shortcut='Home', shortcut_widget=self.area)
@@ -102,7 +101,7 @@ class ChronoTimer(QObject):
         hor_layout.addWidget(self.start_pb)
 
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/pause.png"), QtGui.QIcon.Normal,
+        icon.addPixmap(QtGui.QPixmap("icons:pause.png"), QtGui.QIcon.Normal,
                        QtGui.QIcon.Off)
         self.pause_pb = PushButtonShortcut(icon, 'Pause',
                                            shortcut='Ctrl+p', shortcut_widget=self.area)
@@ -112,7 +111,7 @@ class ChronoTimer(QObject):
         hor_layout.addWidget(self.pause_pb)
 
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/Refresh2.png"), QtGui.QIcon.Normal,
+        icon.addPixmap(QtGui.QPixmap("icons:Refresh2.png"), QtGui.QIcon.Normal,
                        QtGui.QIcon.Off)
         self.reset_pb = PushButtonShortcut(icon, 'Reset',
                                            shortcut='F5', shortcut_widget=self.area)
@@ -184,7 +183,7 @@ class ChronoTimer(QObject):
         # lcd.setPalette(QtGui.QPalette(Qt.red))
         if hasattr(Qt, color):
             palette.setBrush(palette.WindowText, getattr(Qt, color))
-            palette.setColor(palette.Background, QtGui.QColor(0, 0, 0))
+            palette.setColor(palette.Window, QtGui.QColor(0, 0, 0))
         lcd.setPalette(palette)
 
 

pymodaq/utils/daq_utils.py

@@ -5,9 +5,11 @@ import pkgutil
 import platform
 from pathlib import Path
 
-from pymodaq_utils import logger as logger_module
 from pymodaq_utils.config import Config
-from pymodaq_utils.utils import get_entrypoints, ThreadCommand, getLineInfo
+from pymodaq_utils.utils import get_entrypoints, ThreadCommand, getLineInfo, find_keys_from_val, is_64bits, timer  # for backcompat
+from pymodaq_utils.logger import set_logger, get_module_name  # for backcompat
+
+from pymodaq.utils.data import DataFromPlugins   # for backcompat
 
 from pymodaq.utils.config import get_set_preset_path
 
@@ -18,7 +20,7 @@ else:
     from functools import lru_cache as cache
 
 
-logger = logger_module.set_logger(logger_module.get_module_name(__file__))
+logger = set_logger(get_module_name(__file__))
 
 config = Config()
 
@@ -122,6 +124,7 @@ def get_instrument_plugins():  # pragma: no cover
     except Exception as e:
         logger.debug(f'Impossible to import PID utility plugin: {str(e)}')
 
+    plugins_import.sort(key=lambda mod: mod['name'])
     return plugins_import