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

pymodaq/utils/managers/preset_manager_utils.py

@@ -18,6 +18,9 @@ DAQ_1DViewer_Det_types = get_plugins('daq_1Dviewer')
 DAQ_2DViewer_Det_types = get_plugins('daq_2Dviewer')
 DAQ_NDViewer_Det_types = get_plugins('daq_NDviewer')
 
+# Fixed names that will sort the plugin in remote/mock
+REMOTE_ITEMS  = {'LECODirector', 'TCPServer'}
+MOCK_ITEMS = {}
 
 def iterative_show_pb(params):
     for param in params:
@@ -27,6 +30,136 @@ def iterative_show_pb(params):
             iterative_show_pb(param['children'])
 
 
+def find_last_index(list_children:list=[], name_prefix ='',format_string='02.0f'):
+    # Custom function to find last available index
+    child_indexes = ([int(par.name()[len(name_prefix) + 1:]) for par in list_children if name_prefix in par.name()])
+    if child_indexes == []:
+        newindex = 0
+    else:
+        newindex = max(child_indexes) + 1
+    return f'{newindex:{format_string}}'
+
+
+def categorize_items(item_list, remote_items=None, mock_items=None):
+    """
+    Core function: categorize any list of items into Mock/Plugin/Remote.
+    
+    Args:
+        item_list: List of items to categorize
+        remote_items: Custom set of remote items (optional)
+        mock_items: Custom set of mock items (optional)
+    
+    Returns: dict {category: [items]} with only non-empty categories
+    """
+    remote_items = remote_items or REMOTE_ITEMS
+    mock_items = mock_items or MOCK_ITEMS
+    
+    categorized = {'Remote': [], 'Mock': [], 'Plugin': []}
+    
+    for item in item_list:
+        if item in remote_items:
+            categorized['Remote'].append(item)
+        elif item in mock_items or 'mock' in item.lower():
+            categorized['Mock'].append(item)
+        else:
+            categorized['Plugin'].append(item)
+    
+    # Return only non-empty categories
+    return {k: v for k, v in categorized.items() if v}
+
+
+def add_category_layers(dimension_dict, remote_items=None, mock_items=None):
+    """
+    Add category layers to a dimension dictionary.
+    Uses categorize_items for each dimension.
+    
+    Args:
+        dimension_dict: {dimension: [items]}
+    
+    Returns: {dimension: {category: [items]}}
+    """
+    result = {}
+    
+    for dimension, items in dimension_dict.items():
+        # Reuse the core categorization function
+        result[dimension] = categorize_items(items, remote_items, mock_items)
+    
+    return result
+
+
+def make_move_params(typ):
+    params = daq_move_params
+    iterative_show_pb(params)
+
+    parent_module = utils.find_dict_in_list_from_key_val(DAQ_Move_Stage_type, 'name', typ)
+    class_ = getattr(getattr(parent_module['module'], 'daq_move_' + typ),
+                        'DAQ_Move_' + typ)
+    params_hardware = getattr(class_, 'params')
+    iterative_show_pb(params_hardware)
+
+    for main_child in params:
+        if main_child['name'] == 'move_settings':
+            main_child['children'] = params_hardware
+            controller_dict = get_param_dict_from_name(params_hardware, 'controller_ID')
+            controller_dict['value'] = random.randint(0, 9999)
+
+        elif main_child['name'] == 'main_settings':
+            typ_dict = get_param_dict_from_name(main_child['children'], 'move_type')
+            typ_dict['value'] = typ
+
+    return params
+
+
+def make_viewer_params(typ):
+        params = daq_viewer_params
+        iterative_show_pb(params)
+
+        for main_child in params:
+            if main_child['name'] == 'main_settings':
+                for child in main_child['children']:
+                    if child['name'] == 'DAQ_type':
+                        child['value'] = typ[0:5]
+                    if child['name'] == 'detector_type':
+                        child['value'] = typ[6:]
+                    if child['name'] == 'controller_status':
+                        child['visible'] = True
+
+        if '0D' in typ:
+            parent_module = utils.find_dict_in_list_from_key_val(DAQ_0DViewer_Det_types, 'name', typ[6:])
+            class_ = getattr(getattr(parent_module['module'], 'daq_0Dviewer_' + typ[6:]), 'DAQ_0DViewer_' + typ[6:])
+        elif '1D' in typ:
+            parent_module = utils.find_dict_in_list_from_key_val(DAQ_1DViewer_Det_types, 'name', typ[6:])
+            class_ = getattr(getattr(parent_module['module'], 'daq_1Dviewer_' + typ[6:]), 'DAQ_1DViewer_' + typ[6:])
+        elif '2D' in typ:
+            parent_module = utils.find_dict_in_list_from_key_val(DAQ_2DViewer_Det_types, 'name', typ[6:])
+            class_ = getattr(getattr(parent_module['module'], 'daq_2Dviewer_' + typ[6:]), 'DAQ_2DViewer_' + typ[6:])
+        elif 'ND' in typ:
+            parent_module = utils.find_dict_in_list_from_key_val(DAQ_NDViewer_Det_types, 'name', typ[6:])
+            class_ = getattr(getattr(parent_module['module'], 'daq_NDviewer_' + typ[6:]), 'DAQ_NDViewer_' + typ[6:])
+        for main_child in params:
+            if main_child['name'] == 'main_settings':
+                for child in main_child['children']:
+                    if child['name'] == 'axes':
+                        child['visible'] = True
+
+        params_hardware = getattr(class_, 'params')
+        iterative_show_pb(params_hardware)
+
+        for main_child in params:
+            # Was this condition useful? 
+            # if main_child['name'] == 'detector_settings':
+            #     while len(main_child['children']) > 0:
+            #         for child in main_child['children']:
+            #             main_child['children'].remove(child)
+
+            #     main_child['children'].extend(params_hardware)
+            if main_child['name'] == 'detector_settings':
+                main_child['children'] = params_hardware
+        controller_dict = get_param_dict_from_name(main_child['children'], 'controller_ID')
+        controller_dict['value'] = random.randint(0, 9999)
+
+        return params
+    
 class PresetScalableGroupMove(GroupParameter):
     """
         |
@@ -44,10 +177,10 @@ class PresetScalableGroupMove(GroupParameter):
     def __init__(self, **opts):
         opts['type'] = 'groupmove'
         opts['addText'] = "Add"
-        opts['addList'] = [mov['name'] for mov in DAQ_Move_Stage_type]
+        opts['addMenu'] = categorize_items([mov['name'] for mov in DAQ_Move_Stage_type])
         super().__init__(**opts)
 
-    def addNew(self, typ):
+    def addNew(self, typ:tuple):
         """
             Add a child.
 
@@ -57,47 +190,21 @@ class PresetScalableGroupMove(GroupParameter):
             =============== ===========
         """
         name_prefix = 'move'
-
-        child_indexes = [int(par.name()[len(name_prefix) + 1:]) for par in self.children()]
-
-        if child_indexes == []:
-            newindex = 0
-        else:
-            newindex = max(child_indexes) + 1
-
-        params = daq_move_params
-        iterative_show_pb(params)
-
-        parent_module = utils.find_dict_in_list_from_key_val(DAQ_Move_Stage_type, 'name', typ)
-        class_ = getattr(getattr(parent_module['module'], 'daq_move_' + typ),
-                         'DAQ_Move_' + typ)
-        params_hardware = getattr(class_, 'params')
-        iterative_show_pb(params_hardware)
-
-        for main_child in params:
-            if main_child['name'] == 'move_settings':
-                main_child['children'] = params_hardware
-                controller_dict = get_param_dict_from_name(params_hardware, 'controller_ID')
-                controller_dict['value'] = random.randint(0, 9999)
-
-            elif main_child['name'] == 'main_settings':
-                typ_dict = get_param_dict_from_name(main_child['children'], 'move_type')
-                typ_dict['value'] = typ
-
-        child = {'title': 'Actuator {:02.0f}'.format(newindex),
-                 'name': f'{name_prefix}{newindex:02.0f}',
-                 'type': 'group',
-                 'removable': True, 'renamable': False,
-                 'children': [
-                     {'title': 'Name:', 'name': 'name', 'type': 'str',
-                      'value': 'Move {:02.0f}'.format(newindex)},
-                     {'title': 'Init?:', 'name': 'init', 'type': 'bool', 'value': True},
-                     {'title': 'Settings:', 'name': 'params', 'type': 'group', 'children': params},
-                 ]}
-
+        typ = typ[-1] #Only need last entry here
+        new_index = find_last_index(self.children(), name_prefix, format_string='02.0f')
+        params = make_move_params(typ)
+        child = {'title': f'Actuator {new_index}',
+            'name': f'{name_prefix}{new_index}',
+            'type': 'group',
+            'removable': True, 'renamable': False,
+            'children': [
+                {'title': 'Name:', 'name': 'name', 'type': 'str',
+                'value': f'Move {new_index}'},
+                {'title': 'Init?:', 'name': 'init', 'type': 'bool', 'value': True},
+                {'title': 'Settings:', 'name': 'params', 'type': 'group', 'children': params},
+            ]}
         self.addChild(child)
 
-
 registerParameterType('groupmove', PresetScalableGroupMove, override=True)
 
 
@@ -116,20 +223,17 @@ class PresetScalableGroupDet(GroupParameter):
     def __init__(self, **opts):
         opts['type'] = 'groupdet'
         opts['addText'] = "Add"
-        options = []
-        for name in [plugin['name'] for plugin in DAQ_0DViewer_Det_types]:
-            options.append('DAQ0D/' + name)
-        for name in [plugin['name'] for plugin in DAQ_1DViewer_Det_types]:
-            options.append('DAQ1D/' + name)
-        for name in [plugin['name'] for plugin in DAQ_2DViewer_Det_types]:
-            options.append('DAQ2D/' + name)
-        for name in [plugin['name'] for plugin in DAQ_NDViewer_Det_types]:
-            options.append('DAQND/' + name)
-        opts['addList'] = options
+        options = {
+        'DAQ0D': [name for name in [plugin['name'] for plugin in DAQ_0DViewer_Det_types]],
+        'DAQ1D': [name for name in [plugin['name'] for plugin in DAQ_1DViewer_Det_types]],
+        'DAQ2D': [name for name in [plugin['name'] for plugin in DAQ_2DViewer_Det_types]],
+        'DAQND': [name for name in [plugin['name'] for plugin in DAQ_NDViewer_Det_types]],
+         }
+        opts['addMenu'] = add_category_layers(options)
 
         super().__init__(**opts)
 
-    def addNew(self, typ):
+    def addNew(self, typ:tuple):
         """
             Add a child.
 
@@ -140,63 +244,15 @@ class PresetScalableGroupDet(GroupParameter):
         """
         try:
             name_prefix = 'det'
-            child_indexes = [int(par.name()[len(name_prefix) + 1:]) for par in self.children()]
-
-            if child_indexes == []:
-                newindex = 0
-            else:
-                newindex = max(child_indexes) + 1
-
-            params = daq_viewer_params
-            iterative_show_pb(params)
-
-            for main_child in params:
-                if main_child['name'] == 'main_settings':
-                    for child in main_child['children']:
-                        if child['name'] == 'DAQ_type':
-                            child['value'] = typ[0:5]
-                        if child['name'] == 'detector_type':
-                            child['value'] = typ[6:]
-                        if child['name'] == 'controller_status':
-                            child['visible'] = True
-
-            if '0D' in typ:
-                parent_module = utils.find_dict_in_list_from_key_val(DAQ_0DViewer_Det_types, 'name', typ[6:])
-                class_ = getattr(getattr(parent_module['module'], 'daq_0Dviewer_' + typ[6:]), 'DAQ_0DViewer_' + typ[6:])
-            elif '1D' in typ:
-                parent_module = utils.find_dict_in_list_from_key_val(DAQ_1DViewer_Det_types, 'name', typ[6:])
-                class_ = getattr(getattr(parent_module['module'], 'daq_1Dviewer_' + typ[6:]), 'DAQ_1DViewer_' + typ[6:])
-            elif '2D' in typ:
-                parent_module = utils.find_dict_in_list_from_key_val(DAQ_2DViewer_Det_types, 'name', typ[6:])
-                class_ = getattr(getattr(parent_module['module'], 'daq_2Dviewer_' + typ[6:]), 'DAQ_2DViewer_' + typ[6:])
-            elif 'ND' in typ:
-                parent_module = utils.find_dict_in_list_from_key_val(DAQ_NDViewer_Det_types, 'name', typ[6:])
-                class_ = getattr(getattr(parent_module['module'], 'daq_NDviewer_' + typ[6:]), 'DAQ_NDViewer_' + typ[6:])
-            for main_child in params:
-                if main_child['name'] == 'main_settings':
-                    for child in main_child['children']:
-                        if child['name'] == 'axes':
-                            child['visible'] = True
-
-            params_hardware = getattr(class_, 'params')
-            iterative_show_pb(params_hardware)
-
-            for main_child in params:
-                if main_child['name'] == 'detector_settings':
-                    while len(main_child['children']) > 0:
-                        for child in main_child['children']:
-                            main_child['children'].remove(child)
-
-                    main_child['children'].extend(params_hardware)
-            controller_dict = get_param_dict_from_name(main_child['children'], 'controller_ID')
-            controller_dict['value'] = random.randint(0, 9999)
-
-            child = {'title': 'Det {:02.0f}'.format(newindex), 'name': f'{name_prefix}{newindex:02.0f}',
-                     'type': 'group', 'children': [
-                {'title': 'Name:', 'name': 'name', 'type': 'str', 'value': 'Det {:02.0f}'.format(newindex)},
+            typ = "/".join((typ[0],typ[-1])) #Only need first and last element to retrieve associated plugin
+            new_index = find_last_index(list_children=self.children(), name_prefix=name_prefix, format_string='02.0f')
+            params = make_viewer_params(typ)
+            child = {'title': f'Det {new_index}', 'name': f'{name_prefix}{new_index}',
+                        'type': 'group', 'children': [
+                {'title': 'Name:', 'name': 'name', 'type': 'str', 'value': f'Det {new_index}'},
                 {'title': 'Init?:', 'name': 'init', 'type': 'bool', 'value': True},
                 {'title': 'Settings:', 'name': 'params', 'type': 'group', 'children': params},
-            ], 'removable': True, 'renamable': False}
+            ], 'removable': True, 'renamable': False}            
 
             self.addChild(child)
         except Exception as e:

pymodaq/utils/managers/remote_manager.py

@@ -3,6 +3,7 @@ import sys
 
 from qtpy.QtCore import QObject, Signal
 from qtpy import QtGui, QtWidgets
+from qtpy.QtWidgets import QMessageBox, QDialogButtonBox, QDialog
 
 
 from pymodaq.utils.config import get_set_remote_path
@@ -153,9 +154,9 @@ class ShortcutSelection(QtWidgets.QDialog):
         hor_layout.addWidget(label)
         hor_layout.addWidget(self.label)
 
-        buttonBox = QtWidgets.QDialogButtonBox()
-        buttonBox.addButton(QtWidgets.QDialogButtonBox.Ok)
-        buttonBox.addButton(QtWidgets.QDialogButtonBox.Cancel)
+        buttonBox = QDialogButtonBox()
+        buttonBox.addButton(QDialogButtonBox.StandardButton.Ok)
+        buttonBox.addButton(QDialogButtonBox.StandardButton.Cancel)
         layout.addWidget(self.label)
         layout.addWidget(buttonBox)
 
@@ -244,9 +245,9 @@ class JoystickButtonsSelection(QtWidgets.QDialog):
 
         layout.addWidget(self.settings_tree)
 
-        buttonBox = QtWidgets.QDialogButtonBox()
-        buttonBox.addButton(QtWidgets.QDialogButtonBox.Ok)
-        buttonBox.addButton(QtWidgets.QDialogButtonBox.Cancel)
+        buttonBox = QDialogButtonBox()
+        buttonBox.addButton(QDialogButtonBox.StandardButton.Ok)
+        buttonBox.addButton(QDialogButtonBox.StandardButton.Cancel)
         layout.addWidget(buttonBox)
 
         buttonBox.accepted.connect(self.accept)
@@ -261,13 +262,17 @@ class RemoteManager(QObject):
         self.actuators = actuators
         self.detectors = detectors
         if msgbox:
-            msgBox = QtWidgets.QMessageBox()
+            msgBox = QMessageBox()
             msgBox.setText("Preset Manager?")
             msgBox.setInformativeText("What do you want to do?")
-            cancel_button = msgBox.addButton(QtWidgets.QMessageBox.Cancel)
-            new_button = msgBox.addButton("New", QtWidgets.QMessageBox.ActionRole)
-            modify_button = msgBox.addButton('Modify', QtWidgets.QMessageBox.AcceptRole)
-            msgBox.setDefaultButton(QtWidgets.QMessageBox.Cancel)
+            cancel_button = msgBox.addButton(QMessageBox.StandardButton.Cancel)
+            new_button = msgBox.addButton(
+                "New", QMessageBox.ButtonRole.ActionRole
+            )
+            modify_button = msgBox.addButton(
+                "Modify", QMessageBox.ButtonRole.AcceptRole
+            )
+            msgBox.setDefaultButton(QMessageBox.StandardButton.Cancel)
             ret = msgBox.exec()
 
             if msgBox.clickedButton() == new_button:
@@ -443,7 +448,7 @@ class RemoteManager(QObject):
         """
 
         """
-        dialog = QtWidgets.QDialog()
+        dialog = QDialog()
         vlayout = QtWidgets.QVBoxLayout()
         tree = ParameterTree()
         # tree.setMinimumWidth(400)
@@ -452,18 +457,18 @@ class RemoteManager(QObject):
 
         vlayout.addWidget(tree)
         dialog.setLayout(vlayout)
-        buttonBox = QtWidgets.QDialogButtonBox(parent=dialog)
+        buttonBox = QDialogButtonBox(parent=dialog)
 
-        buttonBox.addButton('Save', buttonBox.AcceptRole)
+        buttonBox.addButton("Save", QDialogButtonBox.ButtonRole.AcceptRole)
         buttonBox.accepted.connect(dialog.accept)
-        buttonBox.addButton('Cancel', buttonBox.RejectRole)
+        buttonBox.addButton("Cancel", QDialogButtonBox.ButtonRole.RejectRole)
         buttonBox.rejected.connect(dialog.reject)
 
         vlayout.addWidget(buttonBox)
         dialog.setWindowTitle('Fill in information about the actions and their shortcuts')
         res = dialog.exec()
 
-        if res == dialog.Accepted:
+        if res == QDialog.DialogCode.Accepted:
             # save preset parameters in a xml file
             ioxml.parameter_to_xml_file(
                 self.remote_params, os.path.join(remote_path, self.remote_params.child('filename').value()))

pymodaq/utils/scanner/scan_factory.py

@@ -20,10 +20,10 @@ from pymodaq_utils import math_utils as mutils
 from pymodaq_utils import config as configmod
 
 from pymodaq_gui.managers.parameter_manager import ParameterManager, Parameter
-
 from pymodaq_data.data import Axis, DataDistribution
 
 from pymodaq.utils.scanner.scan_config import ScanConfig
+
 try:
     from pymodaq_gui.config_saver_loader import ConfigSaverLoader
 except ModuleNotFoundError:
@@ -38,8 +38,9 @@ if TYPE_CHECKING:
 
 
 logger = set_logger(get_module_name(__file__))
-config = configmod.Config()
 
+config_utils = configmod.Config()
+config = ControlModulesConfig()
 
 class ScanParameterManager(ParameterManager):
     settings_name = 'scanner_settings'
@@ -86,11 +87,12 @@ class ScannerBase(ScanParameterManager, metaclass=ABCMeta):
     distribution: DataDistribution = abstract_attribute()
     save_settings = True
 
-    def __init__(self, actuators: List[DAQ_Move] = None):
+    def __init__(self, actuators: List[DAQ_Move] = None, display_units=True):
         super().__init__()
         self.positions: np.ndarray = None
         self.n_steps = 1
         self.config = ScanConfig()
+        self.display_units = display_units
         base_path = [act.title for act in actuators] + [self.scan_type, self.scan_subtype]
 
         self.config_saver_loader = ConfigSaverLoader(self.settings,
@@ -101,10 +103,17 @@ class ScannerBase(ScanParameterManager, metaclass=ABCMeta):
 
         self.set_settings_titles()
         self.set_settings_values()
+        if len(actuators) > 0:
+            self.set_units()
 
         if self.check_steps():
             self.set_scan()
 
+    @abstractmethod
+    def set_units(self):
+        """ Update settings units depending on the scanner type and the display_units boolean"""
+        ...
+
     def set_settings_titles(self):
         """Update the settings accordingly with the selected actuators"""
         ...

pymodaq/utils/scanner/scan_selector.py

@@ -311,9 +311,7 @@ class ScanSelector(ParameterManager, QObject):
         self.table_view.horizontalHeader().setStretchLastSection(True)
         self.table_view.setSelectionBehavior(QtWidgets.QTableView.SelectRows)
         self.table_view.setSelectionMode(QtWidgets.QTableView.SingleSelection)
-        styledItemDelegate = QtWidgets.QStyledItemDelegate()
-        styledItemDelegate.setItemEditorFactory(gutils.SpinBoxDelegate())
-        self.table_view.setItemDelegate(styledItemDelegate)
+        self.table_view.setItemDelegate(gutils.SpinBoxDelegate())
 
         self.table_view.setDragEnabled(False)
         self.table_view.setDropIndicatorShown(False)

pymodaq/utils/scanner/scanner.py

@@ -5,6 +5,7 @@ from collections import OrderedDict
 from qtpy.QtCore import QObject, Signal
 from qtpy import QtWidgets
 
+from pymodaq_gui.messenger import messagebox
 from pymodaq_utils.logger import set_logger, get_module_name
 from pymodaq_utils.config import Config
 import pymodaq_utils.utils as utils
@@ -15,13 +16,16 @@ from pymodaq.utils.scanner.scan_factory import ScannerFactory, ScannerBase
 from pymodaq.utils.scanner.utils import ScanInfo
 from pymodaq.utils.scanner.scan_selector import Selector
 from pymodaq.utils.data import DataToExport, DataActuator
+from pymodaq.utils.config import Config as ControlModulesConfig
 
 if TYPE_CHECKING:
     from pymodaq.control_modules.daq_move import DAQ_Move
 
 
 logger = set_logger(get_module_name(__file__))
-config = Config()
+
+config_utils = Config()
+config = ControlModulesConfig()
 scanner_factory = ScannerFactory()
 
 
@@ -50,6 +54,12 @@ class Scanner(QObject, ParameterManager):
          'limits': scanner_factory.scan_types()},
         {'title': 'Scan subtype:', 'name': 'scan_sub_type', 'type': 'list',
          'limits': scanner_factory.scan_sub_types(scanner_factory.scan_types()[0])},
+        {'title': 'Units handling', 'name': 'units_handling', 'type': 'group', 'children': [
+            {'title': 'Display units', 'name': 'display_units', 'type': 'bool', 'value': True},
+            {'title': 'Default units', 'name': 'common_units', 'type': 'str', 'value': '', 'visible': False,
+             'readonly': True},
+            ]},
+
     ]
 
     def __init__(self, parent_widget: QtWidgets.QWidget = None, scanner_items=OrderedDict([]),
@@ -82,9 +92,11 @@ class Scanner(QObject, ParameterManager):
 
     def set_scanner(self):
         try:
-            self._scanner: ScannerBase = scanner_factory.get(self.settings['scan_type'],
-                                                             self.settings['scan_sub_type'],
-                                                             actuators=self.actuators)
+            self._scanner: ScannerBase = scanner_factory.get(
+                self.settings['scan_type'],
+                self.settings['scan_sub_type'],
+                actuators=self.actuators,
+                display_units=self.settings['units_handling', 'display_units'])
 
             while True:
                 child = self._scanner_settings_widget.layout().takeAt(0)
@@ -111,10 +123,25 @@ class Scanner(QObject, ParameterManager):
         if param.name() == 'scan_type':
             self.settings.child('scan_sub_type').setOpts(
                 limits=scanner_factory.scan_sub_types(param.value()))
-        if param.name() in ['scan_type', 'scan_sub_type']:
+        if param.name() in ['scan_sub_type']:
             self.set_scanner()
             self.settings.child('scan_type').setOpts(tip=self._scanner.__doc__)
             self.settings.child('scan_sub_type').setOpts(tip=self._scanner.__doc__)
+        elif param.name() == 'display_units':
+            if not param.value() and len(self.actuators) > 0:
+
+                units = set([act.units for act in self.actuators])
+                if len(units) > 1:
+                    messagebox(title='Info',
+                               text='Could not use the same units for all settings as units are not compatible')
+                    param.setValue(True)
+                    self.settings.child('units_handling', 'common_units').show(False)
+                else:
+                    self.settings.child('units_handling', 'common_units').setValue(list(units)[0])
+                    self.settings.child('units_handling', 'common_units').show(True)
+            else:
+                self.settings.child('units_handling', 'common_units').show(False)
+            self.set_scanner()
 
         self.settings.child('n_steps').setValue(self._scanner.evaluate_steps())
 
@@ -245,10 +272,12 @@ def main():
     from pymodaq.utils.parameter import ParameterTree
     app = QtWidgets.QApplication(sys.argv)
 
+    units = ['nm', 'kW', 'ms']
+
     class MoveMock:
         def __init__(self, ind: int = 0):
             self.title = f'act_{ind}'
-            self.units = f'units_{ind}'
+            self.units = units[ind]
 
     actuators = [MoveMock(ind) for ind in range(3)]
 

pymodaq/utils/scanner/scanners/_1d_scanners.py

@@ -32,8 +32,14 @@ class Scan1DBase(ScannerBase):
     n_axes = 1
     distribution = DataDistribution['uniform']
 
-    def __init__(self, actuators: List = None, **_ignored):
-        super().__init__(actuators=actuators)
+    def __init__(self, actuators: List = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
+
+    def set_units(self):
+        """ Update settings units depending on the scanner type and the display_units boolean"""
+        for child in self.settings.children():
+            child.setOpts(
+                suffix='' if not self.display_units else self.actuators[0].units)
 
     def get_nav_axes(self) -> List[Axis]:
         return [Axis(label=f'{self.actuators[0].title}',
@@ -64,8 +70,9 @@ class Scan1DLinear(Scan1DBase):
     n_axes = 1
     distribution = DataDistribution['uniform']
 
-    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
-        super().__init__(actuators=actuators)
+    def __init__(self, actuators: List['DAQ_Move'] = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
+
 
     def set_scan(self):
         self.positions = mutils.linspace_step(self.settings['start'], self.settings['stop'],
@@ -96,8 +103,8 @@ class Scan1DRandom(Scan1DLinear):
 
     scan_subtype = 'Random'
 
-    def __init__(self, actuators: List = None, **_ignored):
-        super().__init__(actuators=actuators)
+    def __init__(self, actuators: List = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
 
     def set_scan(self):
         self.positions = mutils.linspace_step(self.settings['start'], self.settings['stop'],
@@ -128,8 +135,8 @@ class Scan1DSparse(Scan1DBase):
     distribution = DataDistribution['uniform']  # because in 1D it doesn't matter is spread or
     # uniform, one can easily plot both types on a regulat 1D plot
 
-    def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
-        super().__init__(actuators=actuators)
+    def __init__(self, actuators: List['DAQ_Move'] = None, display_units=True, **_ignored):
+        super().__init__(actuators=actuators, display_units=display_units)
         self.settings.child('parsed_string').setOpts(tip=self.__doc__)
 
     def set_scan(self):
@@ -165,41 +172,3 @@ class Scan1DSparse(Scan1DBase):
         if len(self.actuators) == 1:
             self.settings.child('parsed_string').setOpts(title=f'{self.actuators[0].title} Parsed string:')
 
-try:
-    import adaptive
-
-
-    @ScannerFactory.register()
-    class Scan1DAdaptive(Scan1DBase):
-
-        scan_subtype = 'Adaptive'
-        params = [
-            {'title': 'Loss type', 'name': 'scan_loss', 'type': 'list',
-             'limits': ['default', 'curvature', 'uniform'], 'tip': 'Type of loss used by the algo. to determine next points'},
-            {'title': 'Start:', 'name': 'start', 'type': 'float', 'value': 0.},
-            {'title': 'Stop:', 'name': 'stop', 'type': 'float', 'value': 1.},
-            ]
-        distribution = DataDistribution['spread']
-
-        def __init__(self, actuators: List['DAQ_Move'] = None, **_ignored):
-            super().__init__(actuators=actuators)
-
-        def set_scan(self):
-            self.axes_unique = [np.array([])]
-            self.axes_indexes = np.array([], dtype=int)
-            self.positions = np.array([self.settings['start'], self.settings['stop']])
-
-        def evaluate_steps(self) -> int:
-            return 1
-
-        def get_nav_axes(self) -> List[Axis]:
-            return [Axis(label=f'{self.actuators[0].mod_name} axis',
-                         units=f'{self.actuators[0].units}',
-                         data=self.positions[0])]
-
-        def get_scan_shape(self) -> Tuple[int]:
-            return len(self.positions),
-
-except ModuleNotFoundError:
-    logger.info('adaptive module is not present, no adaptive scan possible')
-