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

pymodaq/utils/leco/daq_move_LECODirector.py

@@ -38,8 +38,6 @@ class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
     settings: Parameter
     controller: ActuatorDirector
 
-    is_multiaxes = False
-    axes_names = []
     params_client = []  # parameters of a client grabber
     data_actuator_type = DataActuatorType['float']  # DataActuatorType['DataActuator']
 
@@ -47,19 +45,21 @@ class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
                                                 'get_actuator_value', 'stop_motion', 'position_is',
                                                 'move_done']
     socket_types = ["ACTUATOR"]
-    params = [
-    ] + comon_parameters_fun(is_multiaxes=is_multiaxes, axes_names=axes_names) + leco_parameters
+    params = comon_parameters_fun() + leco_parameters
 
     def __init__(self, parent=None, params_state=None, **kwargs) -> None:
         super().__init__(parent=parent,
                          params_state=params_state, **kwargs)
         self.register_rpc_methods((
             self.set_info,
+        ))
+        for method in (
             self.set_position,
             self.set_move_done,
             self.set_x_axis,
             self.set_y_axis,
-        ))
+        ):
+            self.listener.register_binary_rpc_method(method, accept_binary_input=True)
 
         # copied, I think it is good:
         self.settings.child('bounds').hide()
@@ -143,22 +143,29 @@ class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
         self.controller.stop_motion()
 
     # Methods accessible via remote calls
-    def _set_position_value(self, position: Union[str, float]) -> DataActuator:
-        if isinstance(position, str):
-            deserializer = DeSerializer.from_b64_string(position)
-            pos = deserializer.dwa_deserialization()
+    def _set_position_value(
+        self, position: Union[str, float, None], additional_payload=None
+    ) -> DataActuator:
+        if position:
+            if isinstance(position, str):
+                deserializer = DeSerializer.from_b64_string(position)
+                pos = deserializer.dwa_deserialization()
+            else:
+                pos = DataActuator(data=position)
+        elif additional_payload is not None:
+            pos = DeSerializer(additional_payload[0]).dwa_deserialization()
         else:
-            pos = DataActuator(data=position)
+            raise ValueError("No position given")
         pos = self.get_position_with_scaling(pos)  # type: ignore
         self._current_value = pos
         return pos
 
-    def set_position(self, position: Union[str, float]) -> None:
-        pos = self._set_position_value(position=position)
+    def set_position(self, position: Union[str, float, None], additional_payload=None) -> None:
+        pos = self._set_position_value(position=position, additional_payload=additional_payload)
         self.emit_status(ThreadCommand('get_actuator_value', [pos]))
 
-    def set_move_done(self, position: Union[str, float]) -> None:
-        pos = self._set_position_value(position=position)
+    def set_move_done(self, position: Union[str, float, None], additional_payload=None) -> None:
+        pos = self._set_position_value(position=position, additional_payload=additional_payload)
         self.emit_status(ThreadCommand('move_done', [pos]))
 
     def set_x_axis(self, data, label: str = "", units: str = "") -> None:

pymodaq/utils/leco/daq_xDviewer_LECODirector.py

@@ -1,5 +1,5 @@
-
-from typing import Union
+from __future__ import annotations
+from typing import Optional, Union
 
 from easydict import EasyDict as edict
 
@@ -29,16 +29,18 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
                                                 "Status", "Done", "Server Closed",
                                                 "Info", "Infos", "Info_xml", 'x_axis', 'y_axis']
     socket_types = ["GRABBER"]
-    params = [
-    ] + comon_parameters + leco_parameters
+    params = comon_parameters + leco_parameters
 
     def __init__(self, parent=None, params_state=None, grabber_type: str = "0D", **kwargs) -> None:
         super().__init__(parent=parent, params_state=params_state, **kwargs)
         self.register_rpc_methods((
             self.set_x_axis,
             self.set_y_axis,
-            self.set_data,
         ))
+        for method in (
+            self.set_data,
+        ):
+            self.listener.register_binary_rpc_method(method, accept_binary_input=True)
 
         self.client_type = "GRABBER"
         self.x_axis = None
@@ -150,7 +152,8 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
         self.y_axis = dict(data=data, label=label, units=units)
         self.emit_y_axis()
 
-    def set_data(self, data: Union[list, str]) -> None:
+    def set_data(self, data: Union[list, str, None],
+                 additional_payload: Optional[list[bytes]]=None) -> None:
         """
         Set the grabbed data signal.
 
@@ -160,10 +163,12 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
         """
         if isinstance(data, str):
             deserializer = DeSerializer.from_b64_string(data)
-            dte = deserializer.dte_deserialization()
-            self.dte_signal.emit(dte)
+        elif additional_payload is not None:
+            deserializer = DeSerializer(additional_payload[0])
         else:
             raise NotImplementedError("Not implemented to set a list of values.")
+        dte = deserializer.dte_deserialization()
+        self.dte_signal.emit(dte)
 
 
 if __name__ == '__main__':

pymodaq/utils/leco/pymodaq_listener.py

@@ -16,8 +16,9 @@ from qtpy.QtCore import QObject, Signal  # type: ignore
 
 from pymodaq_utils.utils import ThreadCommand
 from pymodaq_gui.parameter import ioxml
-from pymodaq.utils.tcp_ip.serializer import DataWithAxes, SERIALIZABLE, DeSerializer
-from pymodaq.utils.leco.utils import serialize_object
+from pymodaq_data.data import DataWithAxes
+from pymodaq_utils.serialize.serializer_legacy import SERIALIZABLE, DeSerializer
+from pymodaq.utils.leco.utils import binary_serialization_to_kwargs
 
 
 class LECOClientCommands(StrEnum):
@@ -220,7 +221,7 @@ class ActorListener(PymodaqListener):
             self.communicator.ask_rpc(
                 receiver=self.remote_name,
                 method="set_data",
-                data=serialize_object(value),
+                **binary_serialization_to_kwargs(value),
             )
 
         elif command.command == 'send_info':
@@ -236,14 +237,14 @@ class ActorListener(PymodaqListener):
             value = command.attribute[0]  # type: ignore
             self.communicator.ask_rpc(receiver=self.remote_name,
                                       method="set_position",
-                                      position=serialize_object(value),
+                                      **binary_serialization_to_kwargs(value, data_key="position"),
                                       )
 
         elif command.command == LECOMoveCommands.MOVE_DONE:
             value = command.attribute[0]  # type: ignore
             self.communicator.ask_rpc(receiver=self.remote_name,
                                       method="set_move_done",
-                                      position=serialize_object(value),
+                                      **binary_serialization_to_kwargs(value, data_key="position"),
                                       )
 
         elif command.command == 'x_axis':
@@ -251,7 +252,7 @@ class ActorListener(PymodaqListener):
             if isinstance(value, SERIALIZABLE):
                 self.communicator.ask_rpc(receiver=self.remote_name,
                                           method="set_x_axis",
-                                          data=serialize_object(value),
+                                          **binary_serialization_to_kwargs(value),
                                           )
             elif isinstance(value, dict):
                 self.communicator.ask_rpc(receiver=self.remote_name, method="set_x_axis", **value)
@@ -263,7 +264,7 @@ class ActorListener(PymodaqListener):
             if isinstance(value, SERIALIZABLE):
                 self.communicator.ask_rpc(receiver=self.remote_name,
                                           method="set_y_axis",
-                                          data=serialize_object(value),
+                                          **binary_serialization_to_kwargs(value),
                                           )
             elif isinstance(value, dict):
                 self.communicator.ask_rpc(receiver=self.remote_name, method="set_y_axis", **value)

pymodaq/utils/leco/utils.py

@@ -1,26 +1,52 @@
+from __future__ import annotations
 import subprocess
 import sys
-from typing import Any, Union, get_args
-
+from typing import Any, Optional, Union, get_args, TypeVar
+from pymodaq_data import data
+from pymodaq.utils import data
 # import also the DeSerializer for easier imports in dependents
-from pymodaq.utils.tcp_ip.serializer import SERIALIZABLE, Serializer, DeSerializer  # type: ignore  # noqa
+from pymodaq_utils.serialize.serializer_legacy import Serializer, DeSerializer, SerializableFactory
+# type: ignore  # noqa
 from pymodaq_utils.logger import set_logger
 
 
 logger = set_logger('leco_utils')
-
+ser_factory = SerializableFactory()
 JSON_TYPES = Union[str, int, float]
 
+SERIALIZABLE = ser_factory.get_serializables()
+
 
 def serialize_object(pymodaq_object: Union[SERIALIZABLE, Any]) -> Union[str, Any]:
     """Serialize a pymodaq object, if it is not JSON compatible."""
     if isinstance(pymodaq_object, get_args(JSON_TYPES)):
         return pymodaq_object
+    else:
+        return Serializer(pymodaq_object).to_b64_string() # will raise a proper error if the object
+    #is not serializable
+
+
+def binary_serialization(
+    pymodaq_object: Union[SERIALIZABLE, Any],
+) -> tuple[Optional[Any], Optional[list[bytes]]]:
+    """Serialize (binary) a pymodaq object, if it is not JSON compatible."""
+    if isinstance(pymodaq_object, get_args(JSON_TYPES)):
+        return pymodaq_object, None
     elif isinstance(pymodaq_object, get_args(SERIALIZABLE)):
-        return Serializer(pymodaq_object).to_b64_string()
+        return None, [Serializer(pymodaq_object).to_bytes()]
     else:
-        raise ValueError(f"{pymodaq_object} of type '{type(pymodaq_object).__name__}' is neither "
-                         "JSON serializable, nor via PyMoDAQ.")
+        raise ValueError(
+            f"{pymodaq_object} of type '{type(pymodaq_object).__name__}' is neither "
+            "JSON serializable, nor via PyMoDAQ."
+        )
+
+
+def binary_serialization_to_kwargs(
+    pymodaq_object: Union[SERIALIZABLE, Any], data_key: str = "data"
+) -> dict[str, Any]:
+    """Create a dictionary of data parameters and of additional payload to send."""
+    d, b = binary_serialization(pymodaq_object=pymodaq_object)
+    return {data_key: d, "additional_payload": b}
 
 
 def run_coordinator():

pymodaq/utils/managers/modules_manager.py

@@ -39,6 +39,7 @@ class ModulesManager(QObject, ParameterManager):
     selected_actuators: list of DAQ_Move
         sublist of actuators
     """
+    settings_name = 'ModulesManagerSettings'
     detectors_changed = Signal(list)
     actuators_changed = Signal(list)
     det_done_signal = Signal(DataToExport)  # dte here contains DataWithAxes
@@ -117,7 +118,7 @@ class ModulesManager(QObject, ParameterManager):
             modules = [modules]
         return [mod.title for mod in modules]
 
-    def get_mods_from_names(self, names, mod='det'):
+    def get_mods_from_names(self, names, mod='det') -> List[Union['DAQ_Move', 'DAQ_Viewer']]:
         """Getter of a list of given modules from their name (title)
 
         Parameters
@@ -172,9 +173,14 @@ class ModulesManager(QObject, ParameterManager):
 
     @property
     def detectors_all(self):
-        """Get the list of all detectors"""
+        """Get/Set the list of all detectors"""
         return self._detectors
 
+    @detectors_all.setter
+    def detectors_all(self, detectors: List['DAQ_Viewer']):
+        self._detectors = detectors
+
+
     @property
     def actuators(self) -> List['DAQ_Move']:
         """Get the list of selected actuators"""
@@ -185,6 +191,10 @@ class ModulesManager(QObject, ParameterManager):
         """Get the list of all actuators"""
         return self._actuators
 
+    @actuators_all.setter
+    def actuators_all(self, actuators: List['DAQ_Move']):
+        self._actuators = actuators
+
     @property
     def modules(self):
         """Get the list of all detectors and actuators"""
@@ -244,11 +254,11 @@ class ModulesManager(QObject, ParameterManager):
         elif param.name() == 'actuators':
             self.actuators_changed.emit(param.value()['selected'])
 
-    def get_det_data_list(self):
+    def get_det_data_list(self) -> DataToExport:
         """Do a snap of selected detectors, to get the list of all the data and processed data"""
 
         self.connect_detectors()
-        datas: DataToExport = self.grab_datas()
+        datas: DataToExport = self.grab_data()
 
         data_list0D = datas.get_full_names('data0D')
         data_list1D = datas.get_full_names('data1D')
@@ -265,6 +275,7 @@ class ModulesManager(QObject, ParameterManager):
             dict(all_items=data_listND, selected=[]))
 
         self.connect_detectors(False)
+        return datas
 
     def get_selected_probed_data(self, dim='0D'):
         """Get the name of selected data names of a given dimensionality
@@ -276,7 +287,7 @@ class ModulesManager(QObject, ParameterManager):
         """
         return self.settings.child('data_dimensions', f'det_data_list{dim.upper()}').value()['selected']
 
-    def grab_datas(self, **kwargs):
+    def grab_data(self, **kwargs):
         """Do a single grab of connected and selected detectors"""
         self.det_done_datas = DataToExport(name=__class__.__name__, control_module='DAQ_Viewer')
         self._received_data = 0
@@ -300,6 +311,10 @@ class ModulesManager(QObject, ParameterManager):
         self.det_done_signal.emit(self.det_done_datas)
         return self.det_done_datas
 
+    def grab_datas(self, **kwargs):
+        """ For back compatibility but use self.grab_data"""
+        return self.grab_data(**kwargs)
+
     def connect_actuators(self, connect=True, slot=None, signal='move_done'):
         """Connect the selected actuators signal to a given or default slot
 
@@ -482,11 +497,6 @@ class ModulesManager(QObject, ParameterManager):
                 self.det_done_flag = True
                 self.settings.child('det_done').setValue(self.det_done_flag)
 
-        # if data.name not in list(self.det_done_datas.keys()):
-        #     self.det_done_datas[data['name']] = data
-        # if len(self.det_done_datas.items()) == len(self.detectors):
-        #     self.det_done_flag = True
-
 
 if __name__ == '__main__':
     import sys

pymodaq/utils/managers/overshoot_manager.py

@@ -118,6 +118,8 @@ class OvershootManager:
         self.det_modules = det_modules
         self.actuators_modules = actuators_modules
 
+        self._activated = False
+
         if msgbox:
             msgBox = QtWidgets.QMessageBox()
             msgBox.setText("Overshoot Manager?")
@@ -138,12 +140,21 @@ class OvershootManager:
             else:  # cancel
                 pass
 
+    @property
+    def activated(self) -> bool:
+        return self._activated
+
+    @activated.setter
+    def activated(self, status: bool):
+        self._activated = status
+
     def set_file_overshoot(self, filename, show=True):
         """
 
         """
         children = ioxml.XML_file_to_parameter(filename)
-        self.overshoot_params = Parameter.create(title='Overshoot', name='Overshoot', type='group', children=children)
+        self.overshoot_params = Parameter.create(title='Overshoot', name='Overshoot', type='group',
+                                                 children=children)
         if show:
             self.show_overshoot()
 
@@ -189,6 +200,39 @@ class OvershootManager:
             ioxml.parameter_to_xml_file(
                 self.overshoot_params, os.path.join(overshoot_path, self.overshoot_params.child('filename').value()))
 
+    def activate_overshoot(self, det_modules, act_modules, status: bool):
+        det_titles = [det.title for det in det_modules]
+        move_titles = [move.title for move in act_modules]
+
+        if self.overshoot_params is not None:
+            for det_param in self.overshoot_params.child(
+                    'Detectors').children():
+                if det_param['trig_overshoot']:
+                    det_index = det_titles.index(det_param.opts['title'])
+                    det_module = det_modules[det_index]
+                    det_module.settings.child(
+                        'main_settings', 'overshoot', 'stop_overshoot').setValue(status)
+                    det_module.settings.child(
+                        'main_settings', 'overshoot', 'overshoot_value').setValue(
+                        det_param['overshoot_value'])
+                    for move_param in det_param.child('params').children():
+                        if move_param['move_overshoot']:
+                            move_index = move_titles.index(move_param.opts['title'])
+                            move_module = act_modules[move_index]
+                            if status:
+                                det_module.overshoot_signal.connect(
+                                    self.create_overshoot_fun(
+                                        move_module, move_param['position']))
+                            else:
+                                try:
+                                    det_module.overshoot_signal.disconnect()
+                                except Exception as e:
+                                    pass
+
+    @staticmethod
+    def create_overshoot_fun(move_module, position):
+        return lambda: move_module.move_abs(position)
+
 
 if __name__ == '__main__':
     app = QtWidgets.QApplication(sys.argv)

pymodaq/utils/managers/preset_manager.py

@@ -19,13 +19,10 @@ import pymodaq.utils.managers.preset_manager_utils  # to register move and det t
 logger = set_logger(get_module_name(__file__))
 
 # check if preset_mode directory exists on the drive
-pid_path = config_mod_pymodaq.get_set_pid_path()
 preset_path = config_mod_pymodaq.get_set_preset_path()
 overshoot_path = config_mod_pymodaq.get_set_overshoot_path()
 layout_path = config_mod_pymodaq.get_set_layout_path()
 
-pid_models = [mod['name'] for mod in get_models()]
-
 
 class PresetManager:
     def __init__(self, msgbox=False, path=None, extra_params=[], param_options=[]):
@@ -38,8 +35,8 @@ class PresetManager:
         self.extra_params = extra_params
         self.param_options = param_options
         self.preset_path = path
-        self.preset_params = None
-        self.pid_type = False
+        self.preset_params: Parameter = None
+
         if msgbox:
             msgBox = QtWidgets.QMessageBox()
             msgBox.setText("Preset Manager?")
@@ -60,33 +57,28 @@ class PresetManager:
             else:  # cancel
                 pass
 
+    @property
+    def filename(self) -> str:
+        try:
+            return self.preset_params['filename']
+        except:
+            return None
+
     def set_file_preset(self, filename, show=True):
         """
 
         """
         status = False
-        self.pid_type = False
         children = ioxml.XML_file_to_parameter(filename)
         self.preset_params = Parameter.create(title='Preset', name='Preset', type='group', children=children)
         if show:
             status = self.show_preset()
         return status
 
-    def get_set_pid_model_params(self, model_file):
-        self.preset_params.child('model_settings').clearChildren()
-        model = get_models(model_file)
-        if model is not None:
-            params = model['class'].params
-            self.preset_params.child('model_settings').addChildren(params)
 
     def set_new_preset(self):
-        self.pid_type = False
         param = [
             {'title': 'Filename:', 'name': 'filename', 'type': 'str', 'value': 'preset_default'},
-            {'title': 'Use PID as actuator:', 'name': 'use_pid', 'type': 'bool', 'value': False},
-            # {'title': 'Saving options:', 'name': 'saving_options', 'type': 'group', 'children': H5Saver.params},
-            {'title': 'PID models:', 'name': 'pid_models', 'type': 'list', 'visible': False,
-             'limits': pid_models},
             {'title': 'Model Settings:', 'name': 'model_settings', 'type': 'group', 'visible': False, 'children': []},
         ]
         params_move = [
@@ -102,9 +94,6 @@ class PresetManager:
         except Exception as e:
             logger.exception(str(e))
 
-        if len(pid_models) != 0:
-            self.get_set_pid_model_params(pid_models[0])
-
         self.preset_params.sigTreeStateChanged.connect(self.parameter_tree_changed)
 
         status = self.show_preset()
@@ -129,12 +118,6 @@ class PresetManager:
                         data[0].child('params', 'main_settings', 'module_name').setValue(data[0].child('name').value())
 
             elif change == 'value':
-
-                if param.name() == 'use_pid':
-                    self.preset_params.child('pid_models').show(param.value())
-                    self.preset_params.child('model_settings').show(param.value())
-                if param.name() == 'pid_models' and param.value() != '':
-                    self.get_set_pid_model_params(param.value())
                 if param.name() == 'name':
                     param.parent().child('params', 'main_settings', 'module_name').setValue(param.value())
 
@@ -148,8 +131,8 @@ class PresetManager:
         dialog = QtWidgets.QDialog()
         vlayout = QtWidgets.QVBoxLayout()
         tree = ParameterTree()
-        tree.setMinimumWidth(400)
-        tree.setMinimumHeight(500)
+        # tree.setMinimumWidth(400)
+        # tree.setMinimumHeight(500)
         tree.setParameters(self.preset_params, showTop=False)
 
         vlayout.addWidget(tree)
@@ -165,20 +148,18 @@ class PresetManager:
         dialog.setWindowTitle('Fill in information about this manager')
         res = dialog.exec()
 
-        if self.pid_type:
-            path = pid_path
-        else:
-            path = self.preset_path
+        path = self.preset_path
+        file= None
 
         if res == dialog.Accepted:
             # save managers parameters in a xml file
             # start = os.path.split(os.path.split(os.path.realpath(__file__))[0])[0]
             # start = os.path.join("..",'daq_scan')
-            filename_without_extension = self.preset_params.child('filename').value()
+            filename_without_extension = self.filename
 
             try:
                 ioxml.parameter_to_xml_file(self.preset_params,
-                                            os.path.join(path, filename_without_extension),
+                                            path.joinpath(filename_without_extension),
                                             overwrite=False)
             except FileExistsError as currenterror:
                 # logger.warning(str(currenterror)+"File " + filename_without_extension + ".xml exists")
@@ -187,24 +168,19 @@ class PresetManager:
                                         message="File exist do you want to overwrite it ?")
                 if user_agreed:
                     ioxml.parameter_to_xml_file(self.preset_params,
-                                                os.path.join(path, filename_without_extension))
+                                                path.joinpath(filename_without_extension))
                     logger.warning(f"File {filename_without_extension}.xml overwriten at user request")
                 else:
                     logger.warning(f"File {filename_without_extension}.xml wasn't saved at user request")
                     # emit status signal to dashboard to write : did not save ?
                 pass
 
-            if not self.pid_type:
-                # check if overshoot configuration and layout configuration with same name exists => delete them if yes
-                file = os.path.splitext(self.preset_params.child('filename').value())[0]
-                file = os.path.join(overshoot_path, file + '.xml')
-                if os.path.isfile(file):
-                    os.remove(file)
-
-                file = os.path.splitext(self.preset_params.child('filename').value())[0]
-                file = os.path.join(layout_path, file + '.dock')
-                if os.path.isfile(file):
-                    os.remove(file)
+            # check if overshoot configuration and layout configuration with same name exists => delete them if yes
+            over_shoot_file = overshoot_path.joinpath(self.filename + '.xml')
+            over_shoot_file.unlink(missing_ok=True)
+
+            layout_file = layout_path.joinpath(self.filename + '.dock')
+            layout_file.unlink(missing_ok=True)
 
         return res == dialog.Accepted
 

pymodaq/utils/managers/preset_manager_utils.py

@@ -4,6 +4,7 @@ from pymodaq_utils.logger import set_logger, get_module_name
 from pymodaq_utils import utils
 
 from pymodaq_gui.parameter.pymodaq_ptypes import registerParameterType, GroupParameter
+from pymodaq_gui.parameter.utils import get_param_dict_from_name
 
 from pymodaq.control_modules.move_utility_classes import params as daq_move_params
 from pymodaq.control_modules.viewer_utility_classes import params as daq_viewer_params
@@ -76,20 +77,23 @@ class PresetScalableGroupMove(GroupParameter):
         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':
-                for child in main_child['children']:
-                    if child['name'] == 'move_type':
-                        child['value'] = typ
-                    if child['name'] == 'controller_ID':
-                        child['value'] = random.randint(0, 9999)
+                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}',
+        child = {'title': 'Actuator {:02.0f}'.format(newindex),
+                 'name': f'{name_prefix}{newindex:02.0f}',
                  'type': 'group',
-                 'removable': True, '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
-                 }], 'removable': True, 'renamable': False}
+                 '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},
+                 ]}
 
         self.addChild(child)
 
@@ -155,8 +159,6 @@ class PresetScalableGroupDet(GroupParameter):
                             child['value'] = typ[6:]
                         if child['name'] == 'controller_status':
                             child['visible'] = True
-                        if child['name'] == 'controller_ID':
-                            child['value'] = random.randint(0, 9999)
 
             if '0D' in typ:
                 parent_module = utils.find_dict_in_list_from_key_val(DAQ_0DViewer_Det_types, 'name', typ[6:])
@@ -186,6 +188,8 @@ class PresetScalableGroupDet(GroupParameter):
                             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': [

pymodaq/utils/managers/remote_manager.py

@@ -17,7 +17,7 @@ logger = set_logger(get_module_name(__file__))
 remote_path = get_set_remote_path()
 remote_types = ['ShortCut', 'Joystick']
 
-actuator_actions = ['move_Rel', 'move_Rel_p', 'move_Rel_m']
+actuator_actions = ['move_rel', 'move_rel_p', 'move_rel_m']
 detector_actions = ['snap', 'grab', 'stop']
 remote_types = ['Keyboard', 'Joystick']
 

pymodaq/utils/messenger.py

@@ -0,0 +1,6 @@
+from pymodaq_utils.warnings import deprecation_msg
+
+from pymodaq_gui.messenger import messagebox
+
+deprecation_msg('importing messagebox from pymodaq directly is deprecated. It should now be'
+                ' imported from pymodaq_gui.messenger')

pymodaq/utils/parameter/__init__.py

@@ -1,6 +1,10 @@
 from pymodaq_gui.parameter import Parameter, ParameterTree, utils, ioxml, pymodaq_ptypes
-
+from sys import modules as sysmodules
 from pymodaq_utils.warnings import deprecation_msg
 
+
+sysmodules["pymodaq.utils.parameter.pymodaq_ptypes"] = pymodaq_ptypes
+
+
 deprecation_msg('Importing Parameter stuff from pymodaq is deprecated in pymodaq>5.0.0,'
                 'please use the pymodaq_gui package')