pymodaq 5.0.17__py3-none-any.whl → 5.1.0__py3-none-any.whl

pymodaq/extensions/daq_scan.py

@@ -16,6 +16,7 @@ from typing import List, Tuple, TYPE_CHECKING
 
 import numpy as np
 from qtpy import QtWidgets, QtCore, QtGui
+from qtpy.QtWidgets import QDialogButtonBox
 from qtpy.QtCore import QObject, Slot, QThread, Signal, QDateTime, QDate, QTime
 
 from pymodaq_utils.logger import set_logger, get_module_name
@@ -41,12 +42,15 @@ from pymodaq.extensions.daq_scan_ui import DAQScanUI
 from pymodaq.utils.h5modules import module_saving
 from pymodaq.utils.scanner.scan_selector import ScanSelector, SelectorItem
 from pymodaq.utils.data import DataActuator
+from pymodaq.utils.config import Config as ControlModulesConfig
 
 
 if TYPE_CHECKING:
     from pymodaq.dashboard import DashBoard
 
-config = Config()
+config_utils = Config()
+config = ControlModulesConfig()
+
 
 logger = set_logger(get_module_name(__file__))
 
@@ -146,7 +150,7 @@ class DAQScan(QObject, ParameterManager):
         self.curvilinear_values = []
         self.plot_colors = utils.plot_colors
 
-        self.scan_thread: QThread = None
+        self.runner_thread: QThread = None
         self._h5saver: H5Saver = None
         self._module_and_data_saver: module_saving.ScanSaver = None
 
@@ -297,14 +301,14 @@ class DAQScan(QObject, ParameterManager):
         # params about dataset attributes and scan attibutes
         date = QDateTime(QDate.currentDate(), QTime.currentTime())
         params_dataset = [{'title': 'Dataset information', 'name': 'dataset_info', 'type': 'group', 'children': [
-            {'title': 'Author:', 'name': 'author', 'type': 'str', 'value': config['user']['name']},
+            {'title': 'Author:', 'name': 'author', 'type': 'str', 'value': config_utils['user']['name']},
             {'title': 'Date/time:', 'name': 'date_time', 'type': 'date_time', 'value': date},
             {'title': 'Sample:', 'name': 'sample', 'type': 'str', 'value': ''},
             {'title': 'Experiment type:', 'name': 'experiment_type', 'type': 'str', 'value': ''},
             {'title': 'Description:', 'name': 'description', 'type': 'text', 'value': ''}]}]
 
         params_scan = [{'title': 'Scan information', 'name': 'scan_info', 'type': 'group', 'children': [
-            {'title': 'Author:', 'name': 'author', 'type': 'str', 'value': config['user']['name']},
+            {'title': 'Author:', 'name': 'author', 'type': 'str', 'value': config_utils['user']['name']},
             {'title': 'Date/time:', 'name': 'date_time', 'type': 'date_time', 'value': date},
             {'title': 'Scan type:', 'name': 'scan_type', 'type': 'str', 'value': ''},
             {'title': 'Scan subtype:', 'name': 'scan_sub_type', 'type': 'str', 'value': ''},
@@ -380,9 +384,9 @@ class DAQScan(QObject, ParameterManager):
 
             vlayout.addWidget(tree)
             dialog.setLayout(vlayout)
-            buttonBox = QtWidgets.QDialogButtonBox(parent=dialog)
-            buttonBox.addButton('Cancel', buttonBox.RejectRole)
-            buttonBox.addButton('Apply', buttonBox.AcceptRole)
+            buttonBox = QDialogButtonBox(parent=dialog)
+            buttonBox.addButton("Cancel", QDialogButtonBox.ButtonRole.RejectRole)
+            buttonBox.addButton("Apply", QDialogButtonBox.ButtonRole.AcceptRole)
             buttonBox.rejected.connect(dialog.reject)
             buttonBox.accepted.connect(dialog.accept)
 
@@ -521,7 +525,7 @@ class DAQScan(QObject, ParameterManager):
     @property
     def h5saver(self):
         if self._h5saver is None:
-            self._h5saver = H5Saver(backend=config('general', 'hdf5_backend'))
+            self._h5saver = H5Saver(backend=config_utils('general', 'hdf5_backend'))
         if self._h5saver.h5_file is None:
             self._h5saver.init_file(update_h5=True)
         if not self._h5saver.isopen():
@@ -600,7 +604,7 @@ class DAQScan(QObject, ParameterManager):
         actuators = self.modules_manager.actuators
         dte = data_mod.DataToExport(name="move_at")
         for ind, pos in enumerate(positions):
-            dte.append(DataActuator(actuators[ind].title, data=float(pos)))
+            dte.append(DataActuator(actuators[ind].title, data=float(pos), units=actuators[ind].units))
 
         self.modules_manager.move_actuators(dte, polling=False)
 
@@ -880,6 +884,13 @@ class DAQScan(QObject, ParameterManager):
         self._metada_dataset_set = True
         return res
 
+    def exit_runner_thread(self, duration : int = 5000):
+        self.runner_thread.quit()
+        terminated = self.runner_thread.wait(duration)
+        if not terminated:
+            self.runner_thread.terminate()
+            self.runner_thread.wait()
+
     def start_scan(self):
         """
             Start an acquisition calling the set_scan function.
@@ -919,27 +930,24 @@ class DAQScan(QObject, ParameterManager):
             self.module_and_data_saver.h5saver = self.h5saver  # force the update as the h5saver ill also be set on each detectors
 
             # mandatory to deal with multithreads
-            if self.scan_thread is not None:
+            if self.runner_thread is not None:
                 self.command_daq_signal.disconnect()
-                if self.scan_thread.isRunning():
-                    self.scan_thread.terminate()
-                    while not self.scan_thread.isFinished():
-                        QThread.msleep(100)
-                    self.scan_thread = None
+                self.exit_runner_thread()
+                self.runner_thread = None
 
-            self.scan_thread = QThread()
+            self.runner_thread = QThread()
 
             scan_acquisition = DAQScanAcquisition(self.settings, self.scanner, self.modules_manager,
                                                   )
 
             if config['scan']['scan_in_thread']:
-                scan_acquisition.moveToThread(self.scan_thread)
+                scan_acquisition.moveToThread(self.runner_thread)
             self.command_daq_signal[utils.ThreadCommand].connect(scan_acquisition.queue_command)
             scan_acquisition.scan_data_tmp[ScanDataTemp].connect(self.save_temp_live_data)
             scan_acquisition.status_sig[utils.ThreadCommand].connect(self.thread_status)
 
-            self.scan_thread.scan_acquisition = scan_acquisition
-            self.scan_thread.start()
+            self.runner_thread.scan_acquisition = scan_acquisition
+            self.runner_thread.start()
 
             self.ui.set_action_enabled('ini_positions', False)
             self.ui.set_action_enabled('start', False)
@@ -992,7 +1000,8 @@ class DAQScan(QObject, ParameterManager):
         self.ui.set_permanent_status('Stoping acquisition')
         self.command_daq_signal.emit(utils.ThreadCommand("stop_acquisition"))
         scan_node = self.module_and_data_saver.get_last_node()
-        scan_node.attrs['scan_done'] = True
+        if scan_node is not None:
+            scan_node.attrs['scan_done'] = True
 
         if not self.dashboard.overshoot:
             self.set_ini_positions()  # do not set ini position again in case overshoot fired
@@ -1095,7 +1104,6 @@ class DAQScanAcquisition(QObject):
 
     def start_acquisition(self):
         try:
-            #todo hoaw to apply newlayout to adaptive mode? => cannot has to be a new extension
 
             self.modules_manager.connect_actuators()
             self.modules_manager.connect_detectors()
@@ -1120,20 +1128,6 @@ class DAQScanAcquisition(QObject):
                         positions = self.scanner.positions_at(self.ind_scan)  # get positions
                     else:
                         pass
-                        #todo update for v4
-                        # positions = learner.ask(1)[0][-1]  # next point to probe
-                        # if self.scanner.scan_type == 'Tabular':  # translate normalized curvilinear position to real coordinates
-                        #     self.curvilinear = positions
-                        #     length = 0.
-                        #     for v in self.scanner.vectors:
-                        #         length += v.norm()
-                        #         if length >= self.curvilinear:
-                        #             vec = v
-                        #             frac_curvilinear = (self.curvilinear - (length - v.norm())) / v.norm()
-                        #             break
-                        #
-                        #     position = (vec.vectorize() * frac_curvilinear).translate_to(vec.p1()).p2()
-                        #     positions = [position.x(), position.y()]
 
                     self.status_sig.emit(
                         utils.ThreadCommand("Update_scan_index",
@@ -1148,21 +1142,7 @@ class DAQScanAcquisition(QObject):
                     QThread.msleep(self.scan_settings['time_flow', 'wait_time_between'])
 
                     #grab datas and wait for grab completion
-                    self.det_done(self.modules_manager.grab_datas(positions=positions), positions)
-
-                    if self.isadaptive:
-                        #todo update for v4
-                        # det_channel = self.modules_manager.get_selected_probed_data()
-                        # det, channel = det_channel[0].split('/')
-                        # if self.scanner.scan_type == 'Tabular':
-                        #     self.curvilinear_array.append(np.array([self.curvilinear]))
-                        #     new_positions = self.curvilinear
-                        # elif self.scanner.scan_type == 'Scan1D':
-                        #     new_positions = positions[0]
-                        # else:
-                        #     new_positions = positions[:]
-                        # learner.tell(new_positions, self.modules_manager.det_done_datas[det]['data0D'][channel]['data'])
-                        pass
+                    self.det_done(self.modules_manager.grab_data(positions=positions), positions)
 
                     # daq_scan wait time
                     QThread.msleep(self.scan_settings.child('time_flow', 'wait_time').value())
@@ -1201,11 +1181,6 @@ class DAQScanAcquisition(QObject):
                 utils.ThreadCommand("add_data",
                                     dict(indexes=indexes, distribution=self.scanner.distribution)))
 
-            #todo related to adaptive (solution lies along the Enlargeable data saver)
-            if self.isadaptive:
-                for ind_ax, nav_axis in enumerate(self.navigation_axes):
-                    nav_axis.append(np.array(positions[ind_ax]))
-
             self.det_done_flag = True
 
             full_names: list = self.scan_settings['plot_options', 'plot_0d']['selected'][:]

pymodaq/extensions/data_mixer/daq_0Dviewer_DataMixer.py

@@ -0,0 +1,97 @@
+from typing import TYPE_CHECKING
+import numpy as np
+
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_data.data import DataToExport
+from pymodaq_gui.parameter import Parameter
+
+from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base, comon_parameters, main
+from pymodaq.utils.data import DataFromPlugins
+
+if TYPE_CHECKING:
+    from pymodaq.extensions.data_mixer import DataMixer
+
+
+class DAQ_0DViewer_DataMixer(DAQ_Viewer_base):
+    """ Instrument plugin class for a OD viewer.
+    
+    This object inherits all functionalities to communicate with PyMoDAQ’s DAQ_Viewer module through inheritance via
+    DAQ_Viewer_base. It makes a bridge between the DAQ_Viewer module and the Python wrapper of a particular instrument.
+
+    Attributes:
+    -----------
+    controller: object
+        The particular object that allow the communication with the hardware, in general a python wrapper around the
+         hardware library.
+
+    """
+    params = (comon_parameters+
+              [
+                  {'title': 'Related Detectors', 'name': 'overridden_detectors', 'type': 'list',
+                   'readonly': True}  # mandatory to know what detectors are related to the DataMixer
+              ])
+
+    def ini_attributes(self):
+        self.controller: DataMixer = None
+
+    def commit_settings(self, param: Parameter):
+        """Apply the consequences of a change of value in the detector settings
+
+        Parameters
+        ----------
+        param: Parameter
+            A given parameter (within detector_settings) whose value has been changed by the user
+        """
+        pass
+
+    def ini_detector(self, controller=None):
+        """Detector communication initialization
+
+        Parameters
+        ----------
+        controller: (object)
+            custom object of a PyMoDAQ plugin (Slave case). None if only one actuator/detector by controller
+            (Master case)
+
+        Returns
+        -------
+        info: str
+        initialized: bool
+            False if initialization failed otherwise True
+        """
+
+        self.controller: DataMixer = controller
+        if self.controller is not None:
+            self.controller.dte_computed_signal.connect(self.grab_done)
+
+        info = "DataMixer Detector Initialized"
+        initialized = True
+        return info, initialized
+
+    def close(self):
+        """Terminate the communication protocol"""
+        pass
+
+    def grab_done(self, dte: DataToExport):
+        self.dte_signal.emit(dte)
+
+    def grab_data(self, Naverage=1, **kwargs):
+        """Start a grab from the detector
+
+        Parameters
+        ----------
+        Naverage: int
+            Number of hardware averaging (if hardware averaging is possible, self.hardware_averaging should be set to
+            True in class preamble and you should code this implementation)
+        kwargs: dict
+            others optionals arguments
+        """
+        self.controller.snap()
+
+    def stop(self):
+        """Stop the current grab hardware wise if necessary"""
+        return ''
+
+
+if __name__ == '__main__':
+    main(__file__)

pymodaq/extensions/data_mixer/data_mixer.py

@@ -0,0 +1,262 @@
+from qtpy import QtWidgets, QtCore
+import numpy as np
+from pathlib import Path
+
+from typing import Optional
+
+from pymodaq_gui import utils as gutils
+from pymodaq_utils.config import Config, ConfigError
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.utils import find_dict_in_list_from_key_val
+from pymodaq_data.data import DataToExport, DataWithAxes
+
+from pymodaq.utils.config import Config as PyMoConfig
+from pymodaq.extensions.utils import CustomExt
+
+
+from pymodaq_gui.plotting.data_viewers.viewer import ViewerDispatcher
+from pymodaq_gui.utils.widgets.qled import QLED
+from pymodaq_gui.parameter import utils as putils
+
+
+from pymodaq.extensions.data_mixer.model import get_models, DataMixerModel
+from pymodaq.extensions.data_mixer.utils import DataMixerConfig, find_key_in_nested_dict
+
+logger = set_logger(get_module_name(__file__))
+
+config_utils = Config()
+config_pymodaq = PyMoConfig()
+
+EXTENSION_NAME = 'Data Mixer'  # the name that will be displayed in the extension list in the
+# dashboard
+CLASS_NAME = 'DataMixer'  # this should be the name of your class defined below
+
+
+class DataMixer(CustomExt):
+    settings_name = 'DataMixerSettings'
+    models = get_models()
+    params = [
+        {'title': 'Models', 'name': 'models', 'type': 'group', 'expanded': True, 'visible': True,
+         'children': [
+             {'title': 'Models class:', 'name': 'model_class', 'type': 'list',
+              'limits': [d['name'] for d in models]},
+             {'title': 'Ini Model', 'name': 'ini_model', 'type': 'action', },
+             {'title': 'Model params:', 'name': 'model_params', 'type': 'group', 'children': []},
+
+         ]}]
+
+    dte_computed_signal = QtCore.Signal(DataToExport)
+
+    def __init__(self, parent: gutils.DockArea, dashboard):
+        super().__init__(parent, dashboard)
+
+        self.model_class: Optional[DataMixerModel] = None
+        self.datamixer_config = DataMixerConfig()
+        self.setup_ui()
+
+        self.settings.child('models', 'ini_model').sigActivated.connect(
+            self.get_action('ini_model').trigger)
+
+    def get_set_model_params(self, model_name):
+        self.settings.child('models', 'model_params').clearChildren()
+        if len(self.models) > 0:
+            model_class = find_dict_in_list_from_key_val(self.models, 'name', model_name)['class']
+            params = getattr(model_class, 'params')
+            self.settings.child('models', 'model_params').addChildren(params)
+
+
+    def setup_docks(self):
+        """Mandatory method to be subclassed to setup the docks layout
+
+        """
+        self.docks['settings'] = gutils.Dock('Settings')
+        self.dockarea.addDock(self.docks['settings'])
+        splitter = QtWidgets.QSplitter(QtCore.Qt.Vertical)
+        self.docks['settings'].addWidget(splitter)
+        splitter.addWidget(self.modules_manager.settings_tree)
+        self.modules_manager.tree.header().setVisible(False)
+        self.modules_manager.settings.child('modules', 'actuators').hide()
+        self.modules_manager.settings.child('move_done').hide()
+        self.modules_manager.settings.child('det_done').hide()
+        self.modules_manager.settings.child('data_dimensions',
+                                            'det_data_list0D').setOpts(height=150)
+        self.modules_manager.settings.child('data_dimensions').hide()
+        self.modules_manager.settings.child('actuators_positions').hide()
+
+        splitter.addWidget(self.settings_tree)
+
+        self.docks['computed'] = gutils.Dock('Computed data')
+        self.dockarea.addDock(self.docks['computed'], 'right')
+
+        self.area_computed = gutils.DockArea()
+        self.docks['computed'].addWidget(self.area_computed)
+
+        self.dte_computed_viewer = ViewerDispatcher(self.area_computed)
+
+        if len(self.models) != 0:
+            self.get_set_model_params(self.models[0]['name'])
+
+    @property
+    def config_path(self) -> Path:
+        return self.datamixer_config.config_path
+
+    def validate_config(self) -> bool:
+        """ Read eventually saved settings from self.datamixer_config
+
+        Example
+        -------
+        utility = find_key_in_nested_dict(self.datamixer_config.to_dict(), 'prediction')
+
+        """
+        return True
+
+    def setup_actions(self):
+        """Method where to create actions to be subclassed. Mandatory
+
+        """
+        self.add_action('quit', 'Quit', 'close2', "Quit program")
+        combo_model = QtWidgets.QComboBox()
+        combo_model.addItems([model['name'] for  model in self.models])
+        self.add_widget('models', combo_model, tip='List of available models')
+        self.add_action('ini_model', 'Init Model', 'ini')
+        self.add_widget('model_led', QLED, toolbar=self.toolbar)
+        self.add_action('snap', 'Snap Detectors', 'snap',
+                        'Snap all selected detectors')
+        self.add_action('create_computed_detectors', 'Create Computed Detectors', 'Add_Step',
+                        tip='Create a DAQ_Viewer Control Module')
+
+    def connect_things(self):
+        """Connect actions and/or other widgets signal to methods"""
+        self.connect_action('quit', self.quit_fun)
+        self.connect_action('models', self.update_model_settings_from_action, signal_name='currentTextChanged')
+        self.connect_action('ini_model', self.ini_model)
+        self.modules_manager.det_done_signal.connect(self.process_data)
+        self.dte_computed_signal.connect(self.plot_computed_results)
+        self.connect_action('snap', self.snap)
+        self.modules_manager.detectors_changed.connect(self.update_connect_detectors)
+        self.connect_action('create_computed_detectors', self.create_computed_detectors)
+
+    def update_model_settings_from_action(self, model: str):
+        self.settings.child('models', 'model_class').setValue(model)
+
+    def process_data(self, dte: DataToExport):
+        if self.model_class is not None:
+            dte_computed = self.model_class.process_dte(dte)
+            self.dte_computed_signal.emit(dte_computed)
+
+    def snap(self):
+        self.modules_manager.grab_data(check_do_override=False)
+
+    def create_computed_detectors(self):
+        try:
+            self.dashboard.add_det_from_extension('DataMixer', 'DAQ0D', 'DataMixer', self)
+            self.dashboard.modules_manager.get_mod_from_name(
+                'DataMixer', 'det').settings.child('detector_settings', 'overridden_detectors').setOpts(
+                limits=self.modules_manager.selected_detectors_name)
+            self.set_action_enabled('create_computed_detectors', False)
+            #self.dashboard.override_det_from_extension(self.modules_manager.selected_detectors_name)
+        except Exception as e:
+            logger.exception(str(e))
+            pass
+
+    def update_connect_detectors(self):
+        try:
+            self.connect_detectors(False)
+        except :
+            pass
+        self.connect_detectors()
+
+    def connect_detectors(self, connect=True):
+        """Connect detectors to DAQ_Logging do_save_continuous method
+
+        Parameters
+        ----------
+        connect: bool
+            If True make the connection else disconnect
+        """
+        self.modules_manager.connect_detectors(connect=connect)
+
+    def plot_computed_results(self, dte):
+        self.dte_computed_viewer.show_data(dte)
+
+    def ini_model(self):
+        if self.model_class is None:
+            self.set_model()
+
+        self.get_action('model_led').set_as_true()
+        self.set_action_enabled('ini_model', False)
+        self.settings.child('models', 'ini_model').setValue(True)
+        self.set_action_enabled('models', False)
+        self.settings.child('models', 'model_class').setOpts(enabled=False)
+        self.modules_manager.settings_tree.setEnabled(False)
+
+        self.update_connect_detectors()
+
+    def set_model(self):
+        model_name = self.settings['models', 'model_class']
+        self.model_class = find_dict_in_list_from_key_val(
+            self.models, 'name', model_name)['class'](self)
+        self.model_class.ini_model_base()
+
+    def setup_menu(self, menubar: QtWidgets.QMenuBar = None):
+        """Non mandatory method to be subclassed in order to create a menubar
+
+        create menu for actions contained into the self._actions, for instance:
+
+        Examples
+        --------
+        >>>file_menu = self.mainwindow.menuBar().addMenu('File')
+        >>>self.affect_to('load', file_menu)
+        >>>self.affect_to('save', file_menu)
+
+        >>>file_menu.addSeparator()
+        >>>self.affect_to('quit', file_menu)
+
+        See Also
+        --------
+        pymodaq.utils.managers.action_manager.ActionManager
+        """
+        # todo create and populate menu using actions defined above in self.setup_actions
+        pass
+
+    def value_changed(self, param):
+        """ Actions to perform when one of the param's value in self.settings is changed from the
+        user interface
+
+        For instance:
+        if param.name() == 'do_something':
+            if param.value():
+                print('Do something')
+                self.settings.child('main_settings', 'something_done').setValue(False)
+
+        Parameters
+        ----------
+        param: (Parameter) the parameter whose value just changed
+        """
+        if param.name() == 'model_class':
+            self.get_set_model_params(param.value())
+            self.get_action('models').setCurrentText(param.value())
+        elif param.name() in putils.iter_children(self.settings.child('models', 'model_params'), []):
+            if self.model_class is not None:
+                self.model_class.update_settings(param)
+
+    def quit_fun(self):
+        self.mainwindow.close()
+        self.dashboard.remove_modules(['DataMixer'])
+
+
+def main():
+    from pymodaq_gui.utils.utils import mkQApp
+    from pymodaq.utils.gui_utils.loader_utils import load_dashboard_with_preset
+
+    app = mkQApp('DataMixer')
+
+    preset_file_name = config_pymodaq('presets', 'default_preset_for_datamixer')
+    dashboard, extension, win = load_dashboard_with_preset(preset_file_name, EXTENSION_NAME)
+    app.exec()
+
+    return dashboard, extension, win
+
+
+if __name__ == '__main__':
+    main()

pymodaq/extensions/data_mixer/model.py

@@ -0,0 +1,108 @@
+import dataclasses
+from typing import List, TYPE_CHECKING
+import importlib
+import inspect
+import pkgutil
+import warnings
+from pathlib import Path
+from typing import Union, List
+
+import numpy as np  # to be imported within models
+
+from pymodaq_utils.utils import find_dict_in_list_from_key_val, get_entrypoints
+from pymodaq_utils.logger import set_logger, get_module_name
+
+from pymodaq_data.data import DataToExport
+
+from pymodaq_gui.managers.parameter_manager import ParameterManager, Parameter
+from pymodaq_gui.config_saver_loader import ConfigSaverLoader
+
+
+logger = set_logger(get_module_name(__file__))
+
+if TYPE_CHECKING:
+    from pymodaq.extensions.data_mixer import DataMixer
+    from pymodaq.utils.managers.modules_manager import ModulesManager
+
+
+class DataMixerModel:
+
+    detectors_name: List[str] = []
+    params = []
+
+    def __init__(self, data_mixer: 'DataMixer'):
+        self.data_mixer = data_mixer
+        self.modules_manager: ModulesManager = data_mixer.modules_manager
+        self.settings: Parameter = self.data_mixer.settings.child('models', 'model_params')
+
+
+    def ini_model_base(self):
+        """ Method to add things that should be executed before instantiating the model"""
+        self.ini_model()
+
+    def ini_model(self):
+        pass
+
+    def update_settings(self, param: Parameter):
+        pass
+
+    def process_dte(self, measurements: DataToExport) -> DataToExport:
+        """
+        Convert the measurements in the units to be fed to the PID (same dimensionality as the setpoint)
+        Parameters
+        ----------
+        measurements: DataToExport
+         DataToExport object from which the model extract a value of the same units as the setpoint
+
+        Returns
+        -------
+        DataToExport: the converted input as 0D DataCalculated stored in a DataToExport
+        """
+        raise NotImplementedError
+
+
+@dataclasses.dataclass
+class PkgMock:
+    value: str
+
+
+def get_models(model_name=None) -> list[dict[(str, str), (str, type)]]:
+    """
+    Get DataMixer Models
+
+    Returns
+    -------
+    list: list of dict containing the name and python module of the found models
+
+    Example
+    -------
+    model = [{'name': 'MyModel', 'class': DataModel}]
+    """
+    models_import = []
+    discovered_models = list(get_entrypoints(group='pymodaq.models'))
+    discovered_models.append(PkgMock('pymodaq.extensions.data_mixer'))
+    if len(discovered_models) > 0:
+        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 DataMixerModel:
+                                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)