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

pymodaq/extensions/daq_scan_ui.py

@@ -0,0 +1,240 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 06/12/2022
+
+@author: Sebastien Weber
+"""
+import sys
+from typing import List, TYPE_CHECKING
+
+from qtpy import QtWidgets, QtCore
+from qtpy.QtCore import Signal
+
+from pymodaq.utils.gui_utils import CustomApp
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils.config import Config, get_set_preset_path
+from pymodaq.utils.gui_utils import DockArea, Dock
+from pymodaq.utils.gui_utils.widgets.spinbox import QSpinBox_ro
+from pymodaq.utils.parameter.pymodaq_ptypes.led import QLED
+from pymodaq.utils.plotting.data_viewers.viewer import ViewerDispatcher, ViewersEnum
+from pymodaq.utils.daq_utils import ThreadCommand
+
+if TYPE_CHECKING:
+    from pymodaq.utils.parameter import ParameterTree
+
+config = Config()
+logger = set_logger(get_module_name(__file__))
+
+
+class DAQScanUI(CustomApp, ViewerDispatcher):
+    """
+
+    """
+    command_sig = Signal(ThreadCommand)
+
+    def __init__(self, parent):
+        CustomApp.__init__(self, parent)
+        self.setup_docks()
+        ViewerDispatcher.__init__(self, self.dockarea, title='Scanner', next_to_dock=self.dock_command)
+
+        self.setup_menu()
+        self.setup_actions()
+        self.connect_things()
+
+    def setup_actions(self):
+        self.add_action('quit', 'Quit the module', 'close2', menu=self.file_menu)
+        self.add_action('ini_positions', 'Init Positions', '', menu=self.action_menu)
+        self.add_action('start', 'Start Scan', 'run2', "Start the scan", menu=self.action_menu)
+        self.add_action('start_batch', 'Start ScanBatches', 'run_all', "Start the batch of scans", menu=self.action_menu)
+        self.add_action('stop', 'Stop Scan', 'stop', "Stop the scan", menu=self.action_menu)
+        self.add_action('move_at', 'Move at doubleClicked', 'move_contour',
+                        "Move to positions where you double clicked", checkable=True, menu=self.action_menu)
+        self.add_action('log', 'Show Log file', 'information2', menu=self.file_menu)
+
+        self.add_action('load', 'Load File', 'Open', menu=self.file_menu, auto_toolbar=False)
+        self.file_menu.addSeparator()
+        self.add_action('save', 'Save file as', 'SaveAs', menu=self.file_menu, auto_toolbar=False)
+        self.add_action('show_file', 'Show file content', '', menu=self.file_menu, auto_toolbar=False)
+
+        self.add_action('navigator', 'Show Navigator', '', menu=self.settings_menu, auto_toolbar=False)
+        self.add_action('batch', 'Show Batch Scanner', '', menu=self.settings_menu, auto_toolbar=False)
+        self.set_action_visible('start_batch', False)
+
+    def enable_start_stop(self, enable=True):
+        """If True enable main buttons to launch/stop scan"""
+        self.set_action_enabled('start', enable)
+        self.set_action_enabled('stop', enable)
+
+    def connect_things(self):
+        self.connect_action('quit', lambda: self.command_sig.emit(ThreadCommand('quit')))
+        self.connect_action('ini_positions', lambda: self.command_sig.emit(ThreadCommand('ini_positions')))
+        self.connect_action('start', lambda: self.command_sig.emit(ThreadCommand('start')))
+        self.connect_action('start_batch', lambda: self.command_sig.emit(ThreadCommand('start_batch')))
+        self.connect_action('stop', lambda: self.command_sig.emit(ThreadCommand('stop')))
+        self.connect_action('move_at', lambda: self.command_sig.emit(ThreadCommand('move_at')))
+        self.connect_action('log', lambda: self.command_sig.emit(ThreadCommand('show_log', )))
+
+        self.connect_action('load', lambda: self.command_sig.emit(ThreadCommand('load')))
+        self.connect_action('save', lambda: self.command_sig.emit(ThreadCommand('save')))
+        self.connect_action('show_file', lambda: self.command_sig.emit(ThreadCommand('show_file')))
+        self.connect_action('navigator', lambda: self.command_sig.emit(ThreadCommand('navigator')))
+        self.connect_action('batch', lambda: self.command_sig.emit(ThreadCommand('batch')))
+
+    def setup_menu(self):
+        self.menubar = QtWidgets.QMenuBar()
+        self.menubar.setMaximumHeight(30)
+        self.mainwindow.setMenuBar(self.menubar)
+        self.file_menu = self.menubar.addMenu('File')
+        self.settings_menu = self.menubar.addMenu('Settings')
+        self.action_menu = self.menubar.addMenu('Actions')
+
+    def setup_docks(self):
+        self.dock_command = Dock('Scan Command')
+        self.dockarea.addDock(self.dock_command)
+
+        widget_command = QtWidgets.QWidget()
+        widget_command.setLayout(QtWidgets.QVBoxLayout())
+        self.dock_command.addWidget(widget_command)
+        widget_command.layout().addWidget(self._toolbar)
+
+        splitter_widget = QtWidgets.QSplitter(QtCore.Qt.Horizontal)
+        splitter_v_widget = QtWidgets.QSplitter(QtCore.Qt.Vertical)
+        widget_command.layout().addWidget(splitter_widget)
+        splitter_widget.addWidget(splitter_v_widget)
+        self.module_widget = QtWidgets.QWidget()
+        self.module_widget.setLayout(QtWidgets.QVBoxLayout())
+        self.module_widget.setMinimumWidth(220)
+        self.module_widget.setMaximumWidth(400)
+
+        self.plotting_widget = QtWidgets.QWidget()
+        self.plotting_widget.setLayout(QtWidgets.QVBoxLayout())
+        self.plotting_widget.setMinimumWidth(220)
+        self.plotting_widget.setMaximumWidth(400)
+
+        settings_widget = QtWidgets.QWidget()
+        settings_widget.setLayout(QtWidgets.QVBoxLayout())
+        settings_widget.setMinimumWidth(220)
+
+        splitter_v_widget.addWidget(self.module_widget)
+        splitter_v_widget.addWidget(self.plotting_widget)
+
+        splitter_v_widget.setSizes([400, 400])
+        splitter_widget.addWidget(settings_widget)
+
+
+        self._statusbar = QtWidgets.QStatusBar()
+        self.mainwindow.setStatusBar(self._statusbar)
+        self.populate_status_bar()
+
+        self.settings_toolbox = QtWidgets.QToolBox()
+        settings_widget.layout().addWidget(self.settings_toolbox)
+        self.scanner_widget = QtWidgets.QWidget()
+        self.scanner_widget.setLayout(QtWidgets.QVBoxLayout())
+        self.settings_toolbox.addItem(self.scanner_widget, 'Scanner Settings')
+
+    def add_settings_toolbox_widget(self, widget: QtWidgets.QWidget, name: str):
+        """Add a widget, usaually a ParameterTree to the SettingsToolbox"""
+        self.settings_toolbox.addItem(widget, name)
+
+    def add_scanner_settings(self, tree: 'ParameterTree'):
+        """Adds a  ParameterTree to the Scanner settings widget"""
+        self.scanner_widget.layout().addWidget(tree)
+
+    def populate_toolbox_widget(self, widgets: List[QtWidgets.QWidget], names: List[str]):
+        for widget, name in zip(widgets, names):
+            self.settings_toolbox.addItem(widget, name)
+
+    def set_scanner_settings(self, settings_tree: QtWidgets.QWidget):
+        while True:
+            child = self.scanner_widget.layout().takeAt(0)
+            if not child:
+                break
+            child.widget().deleteLater()
+            QtWidgets.QApplication.processEvents()
+
+        self.scanner_widget.layout().addWidget(settings_tree)
+
+    def set_modules_settings(self, settings_widget):
+        self.module_widget.layout().addWidget(settings_widget)
+
+    def set_plotting_settings(self, settings_plotting):
+        self.plotting_widget.layout().addWidget(settings_plotting)
+
+    def populate_status_bar(self):
+        self._status_message_label = QtWidgets.QLabel('Initializing')
+        self._n_scan_steps_sb = QSpinBox_ro()
+        self._n_scan_steps_sb.setToolTip('Total number of steps')
+        self._indice_scan_sb = QSpinBox_ro()
+        self._indice_scan_sb.setToolTip('Current step value')
+        self._indice_average_sb = QSpinBox_ro()
+        self._indice_average_sb.setToolTip('Current average value')
+        
+        self._scan_done_LED = QLED()
+        self._scan_done_LED.set_as_false()
+        self._scan_done_LED.clickable = False
+        self._scan_done_LED.setToolTip('Scan done state')
+        self._statusbar.addPermanentWidget(self._status_message_label)
+
+        self._statusbar.addPermanentWidget(self._n_scan_steps_sb)
+        self._statusbar.addPermanentWidget(self._indice_scan_sb)
+        self._statusbar.addPermanentWidget(self._indice_average_sb)
+        self._indice_average_sb.setVisible(False)
+        self._statusbar.addPermanentWidget(self._scan_done_LED)
+
+    @property
+    def n_scan_steps(self):
+        return self._n_scan_steps_sb.value()
+
+    @n_scan_steps.setter
+    def n_scan_steps(self, nsteps: int):
+        self._n_scan_steps_sb.setValue(nsteps)
+
+    def display_status(self, status: str, wait_time=1000):
+        self._statusbar.showMessage(status, wait_time)
+        
+    def set_permanent_status(self, status: str):
+        self._status_message_label.setText(status)
+
+    def set_scan_step(self, step_ind: int):
+        self._indice_scan_sb.setValue(step_ind)
+
+    def show_average_step(self, show: bool = True):
+        self._indice_average_sb.setVisible(show)
+
+    def set_scan_step_average(self, step_ind: int):
+        self._indice_average_sb.setValue(step_ind)
+
+    def set_scan_done(self, done=True):
+        self._scan_done_LED.set_as(done)
+
+    def update_viewers(self, viewers_type: List[ViewersEnum], viewers_name: List[str] = None, force=False):
+        super().update_viewers(viewers_type, viewers_name, force)
+        self.command_sig.emit(ThreadCommand('viewers_changed', attribute=dict(viewer_types=self.viewer_types,
+                                                                              viewers=self.viewers)))
+
+def main():
+
+    app = QtWidgets.QApplication(sys.argv)
+
+    win = QtWidgets.QMainWindow()
+    dockarea = DockArea()
+    win.setCentralWidget(dockarea)
+    win.resize(1000, 500)
+    win.setWindowTitle('DAQScan Extension')
+
+    prog = DAQScanUI(dockarea)
+    win.show()
+
+
+    def print_command_sig(cmd_sig):
+        print(cmd_sig)
+        prog.display_status(str(cmd_sig))
+
+    prog.command_sig.connect(print_command_sig)
+    prog.update_viewers([ViewersEnum['Viewer0D'], ViewersEnum['Viewer1D'], ViewersEnum['Viewer2D']])
+
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':
+    main()

pymodaq/extensions/h5browser.py

@@ -0,0 +1,23 @@
+import sys
+from qtpy import QtWidgets
+from pymodaq.utils.h5modules.browsing import H5Browser
+from pymodaq.utils.config import Config
+
+config = Config()
+
+
+def main():
+    app = QtWidgets.QApplication(sys.argv)
+    if config['style']['darkstyle']:
+        import qdarkstyle
+        app.setStyleSheet(qdarkstyle.load_stylesheet())
+
+    win = QtWidgets.QMainWindow()
+    prog = H5Browser(win)
+    win.show()
+    QtWidgets.QApplication.processEvents()
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':
+    main()

pymodaq/{pid → extensions/pid}/__init__.py

@@ -1,7 +1,9 @@
 import importlib
 from pathlib import Path
-from pymodaq.daq_utils import daq_utils as utils
-logger = utils.set_logger('move_plugins', add_to_console=False)
+
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils import daq_utils as utils
+logger = set_logger('move_plugins', add_to_console=False)
 
 for path in Path(__file__).parent.iterdir():
     try:

pymodaq/{pid → extensions/pid}/daq_move_PID.py

@@ -1,5 +1,5 @@
-from pymodaq.daq_utils.daq_utils import ThreadCommand
-from pymodaq.daq_move.utility_classes import DAQ_Move_base, comon_parameters_fun
+from pymodaq.utils.daq_utils import ThreadCommand
+from pymodaq.control_modules.move_utility_classes import DAQ_Move_base, comon_parameters_fun
 from easydict import EasyDict as edict
 
 

pymodaq/{pid → extensions/pid}/pid_controller.py

@@ -1,22 +1,25 @@
+import time
+from functools import partial  # needed for the button to sync setpoint with currpoint
 
+from pyqtgraph.widgets.SpinBox import SpinBox
 from qtpy import QtGui, QtWidgets
 from qtpy.QtCore import QObject, Slot, QThread, Signal
-from pyqtgraph.widgets.SpinBox import SpinBox
 
-from pymodaq.daq_utils.parameter import utils as putils
-from pymodaq.daq_utils.daq_utils import ThreadCommand, set_logger, get_module_name, \
-    get_models, find_dict_in_list_from_key_val
-from pymodaq.daq_utils.managers.modules_manager import ModulesManager
-from pyqtgraph.parametertree import Parameter, ParameterTree
-from pymodaq.daq_utils.plotting.data_viewers.viewer0D import Viewer0D
-from pymodaq.daq_utils.gui_utils.widgets import QLED
-from pymodaq.pid.utils import OutputToActuator, InputFromDetector
-from pymodaq.daq_utils.gui_utils.dock import DockArea, Dock
 from simple_pid import PID
-import time
+
+from pymodaq.utils.parameter import utils as putils
+from pymodaq.utils.parameter import Parameter, ParameterTree
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils.daq_utils import ThreadCommand, find_dict_in_list_from_key_val
+from pymodaq.utils.managers.modules_manager import ModulesManager
+from pymodaq.utils.plotting.data_viewers.viewer0D import Viewer0D
+from pymodaq.utils.gui_utils.widgets import QLED
+from pymodaq.extensions.pid.utils import OutputToActuator, InputFromDetector, get_models
+from pymodaq.utils.gui_utils.dock import DockArea, Dock
 
 logger = set_logger(get_module_name(__file__))
 
+
 def convert_output_limits(lim_min=-10., min_status=False, lim_max=10., max_status=False):
     output = [None, None]
     if min_status:
@@ -77,7 +80,7 @@ class DAQ_PID(QObject):
     ]
 
     def __init__(self, dockarea):
-        
+
         super().__init__()
 
         self.settings = Parameter.create(title='PID settings', name='pid_settings', type='group', children=self.params)
@@ -160,7 +163,7 @@ class DAQ_PID(QObject):
 
     def enable_controls_pid(self, enable=False):
         self.ini_PID_action.setEnabled(enable)
-        #self.setpoint_sb.setOpts(enabled=enable)
+        # self.setpoint_sb.setOpts(enabled=enable)
 
     def enable_controls_pid_run(self, enable=False):
         self.run_action.setEnabled(enable)
@@ -228,10 +231,11 @@ class DAQ_PID(QObject):
         lab = QtWidgets.QLabel('Target Value:')
         self.toolbar_layout.addWidget(lab, 3, 0, 1, 2)
 
-
         lab1 = QtWidgets.QLabel('Current Value:')
         self.toolbar_layout.addWidget(lab1, 4, 0, 1, 2)
 
+        labmaj = QtWidgets.QLabel('Sync Value:')
+        self.toolbar_layout.addWidget(labmaj, 5, 0, 1, 2)
 
         # create main parameter tree
         self.settings_tree = ParameterTree()
@@ -288,7 +292,6 @@ class DAQ_PID(QObject):
             setp.setEnabled(not self.pause_action.isChecked())
         self.command_pid.emit(ThreadCommand('pause_PID', [self.pause_action.isChecked()]))
 
-
     def stop_moves(self, overshoot):
         """
             Foreach module of the move module object list, stop motion.
@@ -353,15 +356,15 @@ class DAQ_PID(QObject):
     def set_setpoints_buttons(self):
         self.setpoints_sb = []
         self.currpoints_sb = []
+        self.syncvalue_pb = []
         for ind_set in range(self.model_class.Nsetpoints):
-
             self.setpoints_sb.append(SpinBox())
             self.setpoints_sb[-1].setMinimumHeight(40)
             font = self.setpoints_sb[-1].font()
             font.setPointSizeF(20)
             self.setpoints_sb[-1].setFont(font)
             self.setpoints_sb[-1].setDecimals(6)
-            self.toolbar_layout.addWidget(self.setpoints_sb[-1], 3, 2+ind_set, 1, 1)
+            self.toolbar_layout.addWidget(self.setpoints_sb[-1], 3, 2 + ind_set, 1, 1)
             self.setpoints_sb[-1].valueChanged.connect(self.update_runner_setpoints)
 
             self.currpoints_sb.append(SpinBox())
@@ -372,10 +375,20 @@ class DAQ_PID(QObject):
             font = self.currpoints_sb[-1].font()
             font.setPointSizeF(20)
             self.currpoints_sb[-1].setFont(font)
-            self.toolbar_layout.addWidget(self.currpoints_sb[-1], 4, 2+ind_set, 1, 1)
+            self.toolbar_layout.addWidget(self.currpoints_sb[-1], 4, 2 + ind_set, 1, 1)
 
+            self.syncvalue_pb.append(QtWidgets.QPushButton('Synchro {}'.format(ind_set)))
+            self.syncvalue_pb[ind_set].clicked.connect(partial(self.currpoint_as_setpoint, ind_set))
+            self.toolbar_layout.addWidget(self.syncvalue_pb[-1], 5, 2 + ind_set)
         self.setpoints_signal.connect(self.setpoints_external)
 
+    def currpoint_as_setpoint(self, i=0):
+        '''
+        Function used by the sync buttons. The button i will attribute the value of the i-th currpoint to the i-th setpoint.
+        '''
+        self.setpoints_sb[i].setValue(self.curr_points[i])
+        self.update_runner_setpoints
+
     def quit_fun(self):
         """
         """
@@ -432,16 +445,15 @@ class DAQ_PID(QObject):
                 elif param.name() in putils.iter_children(
                         self.settings.child('main_settings', 'pid_controls', 'output_limits'), []):
 
-
                     output_limits = convert_output_limits(
                         self.settings.child('main_settings', 'pid_controls', 'output_limits',
                                             'output_limit_min').value(),
                         self.settings.child('main_settings', 'pid_controls', 'output_limits',
-                                           'output_limit_min_enabled').value(),
+                                            'output_limit_min_enabled').value(),
                         self.settings.child('main_settings', 'pid_controls', 'output_limits',
-                                                               'output_limit_max').value(),
+                                            'output_limit_max').value(),
                         self.settings.child('main_settings', 'pid_controls', 'output_limits',
-                                           'output_limit_max_enabled').value())
+                                            'output_limit_max_enabled').value())
 
                     self.command_pid.emit(ThreadCommand('update_options', dict(output_limits=output_limits)))
 
@@ -493,8 +505,8 @@ class PIDRunner(QObject):
         Nsetpoints = model_class.Nsetpoints
         self.current_time = 0
         self.inputs_from_dets = InputFromDetector(values=setpoints)
-        self.outputs = None
-        self.outputs_to_actuators = OutputToActuator(values=[0. for ind in range(Nsetpoints)])
+        self.outputs = [0. for _ in range(Nsetpoints)]
+        self.outputs_to_actuators = OutputToActuator(values=[0. for _ in range(Nsetpoints)])
 
         if 'sample_time' in params:
             self.sample_time = params['sample_time']
@@ -516,11 +528,11 @@ class PIDRunner(QObject):
     #     self.timeout_timer.timeout.connect(self.timeout)
     #
     def timerEvent(self, event):
-       self.pid_output_signal.emit(dict(output=self.outputs_to_actuators.values,
-                                             input=self.inputs_from_dets.values))
+        self.pid_output_signal.emit(dict(output=self.outputs_to_actuators.values,
+                                         input=self.inputs_from_dets.values))
 
     @Slot(ThreadCommand)
-    def queue_command(self, command=ThreadCommand()):
+    def queue_command(self, command: ThreadCommand):
         """
         """
         if command.command == "start_PID":
@@ -617,11 +629,11 @@ class PIDRunner(QObject):
     def set_option(self, **option):
         for pid in self.pids:
             for key in option:
-                    if hasattr(pid, key):
-                        if key == 'sample_time':
-                            setattr(pid, key, option[key] / 1000)
-                        else:
-                            setattr(pid, key, option[key])
+                if hasattr(pid, key):
+                    if key == 'sample_time':
+                        setattr(pid, key, option[key] / 1000)
+                    else:
+                        setattr(pid, key, option[key])
 
     def run_PID(self, last_values):
         logger.info('Stabilization started')
@@ -632,10 +644,10 @@ class PIDRunner(QObject):
         for ind, pid in enumerate(self.pids):
             if pause_state:
                 pid.set_auto_mode(False)
-            logger.info('Stabilization paused')
-        else:
-            pid.set_auto_mode(True, self.outputs[ind])
-            logger.info('Stabilization restarted from pause')
+                logger.info('Stabilization paused')
+            else:
+                pid.set_auto_mode(True, self.outputs[ind])
+                logger.info('Stabilization restarted from pause')
         self.paused = pause_state
 
     def stop_PID(self):

pymodaq/{pid → extensions/pid}/utils.py

@@ -1,5 +1,14 @@
-from pymodaq.daq_utils.gui_utils.dock import DockArea, Dock
-from pymodaq.daq_utils.daq_utils import get_plugins, set_logger, get_module_name
+import importlib
+import inspect
+import pkgutil
+from importlib import metadata
+from pathlib import Path
+
+from pymodaq.utils.gui_utils.dock import DockArea
+from pymodaq.utils.daq_utils import get_plugins
+from pymodaq.utils.logger import get_module_name, set_logger
+from pymodaq.utils.daq_utils import find_dict_in_list_from_key_val
+
 logger = set_logger(get_module_name(__file__))
 
 DAQ_Move_Stage_type = get_plugins('daq_move')
@@ -9,7 +18,6 @@ DAQ_2DViewer_Det_types = get_plugins('daq_2Dviewer')
 DAQ_NDViewer_Det_types = get_plugins('daq_NDviewer')
 
 
-
 class InputFromDetector:
     def __init__(self, values=[]):
         super().__init__()
@@ -136,11 +144,10 @@ class PIDModelGeneric:
 
 def main(xmlfile):
     from pymodaq.dashboard import DashBoard
-    from pymodaq.daq_utils.config import get_set_preset_path
-    from pymodaq.daq_utils import gui_utils as gutils
+    from pymodaq.utils.config import get_set_preset_path
     from pathlib import Path
     from qtpy import QtWidgets
-    from pymodaq.pid.pid_controller import DAQ_PID
+    from extensions.pid.pid_controller import DAQ_PID
 
     import sys
     app = QtWidgets.QApplication(sys.argv)
@@ -175,3 +182,42 @@ def main(xmlfile):
         ret = msgBox.exec()
 
     sys.exit(app.exec_())
+
+
+def get_models(model_name=None):
+    """
+    Get PID Models as a list to instantiate Control Actuators per degree of liberty in the model
+
+    Returns
+    -------
+    list: list of disct containting the name and python module of the found models
+    """
+    from pymodaq.extensions.pid.utils import PIDModelGeneric
+    models_import = []
+    entry_points = metadata.entry_points()
+    if 'pymodaq.pid_models' in entry_points:
+        discovered_models = entry_points['pymodaq.pid_models']
+        for pkg in discovered_models:
+            try:
+                module = importlib.import_module(pkg.value)
+                module_name = pkg.value
+
+                for mod in pkgutil.iter_modules([str(Path(module.__file__).parent.joinpath('models'))]):
+                    try:
+                        model_module = importlib.import_module(f'{module_name}.models.{mod.name}', module)
+                        classes = inspect.getmembers(model_module, inspect.isclass)
+                        for name, klass in classes:
+                            if klass.__base__ is PIDModelGeneric:
+                                models_import.append({'name': mod.name, 'module': model_module, 'class': klass})
+                                break
+
+                    except Exception as e:  # pragma: no cover
+                        logger.warning(str(e))
+
+            except Exception as e:  # pragma: no cover
+                logger.warning(f'Impossible to import the {pkg.value} extension: {str(e)}')
+
+    if model_name is None:
+        return models_import
+    else:
+        return find_dict_in_list_from_key_val(models_import, 'name', model_name)

pymodaq/extensions/utils.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 27/10/2022
+
+@author: Sebastien Weber
+"""
+import importlib
+from importlib import metadata
+from pymodaq.utils import logger as logger_module
+
+logger = logger_module.set_logger(logger_module.get_module_name(__file__))
+
+
+def get_extensions():
+    """
+    Get pymodaq extensions as a list
+
+    Returns
+    -------
+    list: list of disct containting the name and module of the found extension
+    """
+    extension_import = []
+    entry_points = metadata.entry_points()
+    if 'pymodaq.extensions' in entry_points:
+        discovered_extension = entry_points['pymodaq.extensions']
+
+        for pkg in discovered_extension:
+            try:
+                module = importlib.import_module(pkg.value)
+                if hasattr(module, 'NICE_NAME'):
+                    name = module.NICE_NAME
+                else:
+                    name = pkg.value
+                extension = {'name': name, 'module': module}
+                extension_import.append(extension)
+
+            except Exception as e:  # pragma: no cover
+                logger.warning(f'Impossible to import the {pkg.value} extension: {str(e)}')
+
+    return extension_import

pymodaq/post_treatment/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 27/10/2022
+
+@author: Sebastien Weber
+"""