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

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')

pymodaq/utils/tcp_ip/mysocket.py

@@ -4,115 +4,9 @@ Created the 26/10/2023
 
 @author: Sebastien Weber
 """
-import socket
-from typing import Union
+from pymodaq_data.serialize.mysocket import Socket
 
-from pymodaq.utils.tcp_ip.serializer import Serializer
-
-
-class Socket:
-    """Custom Socket wrapping the built-in one and added functionalities to
-    make sure message have been sent and received entirely"""
-    def __init__(self, socket: socket.socket = None):
-        super().__init__()
-        self._socket = socket
-
-    def __eq__(self, other_obj):
-        if isinstance(other_obj, Socket):
-            other_obj = other_obj.socket
-        return self.socket == other_obj
-
-    @property
-    def socket(self):
-        return self._socket
-
-    def bind(self, *args, **kwargs):
-        return self.socket.bind(*args, **kwargs)
-
-    def listen(self, *args, **kwargs):
-        return self.socket.listen(*args, **kwargs)
-
-    def getsockname(self, *args, **kwargs):
-        return self.socket.getsockname(*args, **kwargs)
-
-    def accept(self):
-        sock, addr = self.socket.accept()
-        return Socket(sock), addr
-
-    def connect(self, *args, **kwargs):
-        return self.socket.connect(*args, **kwargs)
-
-    def send(self, *args, **kwargs):
-        return self.socket.send(*args, **kwargs)
-
-    def sendall(self, *args, **kwargs):
-        return self.socket.sendall(*args, **kwargs)
-
-    def recv(self, *args, **kwargs):
-        return self.socket.recv(*args, **kwargs)
-
-    def close(self):
-        return self.socket.close()
-
-    def check_sended(self, data_bytes: bytes):
-        """
-        Make sure all bytes are sent through the socket
-        Parameters
-        ----------
-        data_bytes: bytes
-        """
-        if not isinstance(data_bytes, bytes):
-            raise TypeError(f'{data_bytes} should be an bytes string, not a {type(data_bytes)}')
-        sended = 0
-        while sended < len(data_bytes):
-            sended += self.socket.send(data_bytes[sended:])
-
-    def check_sended_with_serializer(self, obj: object):
-        """ Convenience function to convert permitted objects to bytes and then use the check_sended method
-
-        For a list of allowed objects, see :meth:`Serializer.to_bytes`
-        """
-        self.check_sended(Serializer(obj).to_bytes())
-
-    def check_received_length(self, length) -> bytes:
-        """
-        Make sure all bytes (length) that should be received are received through the socket
-
-        Parameters
-        ----------
-        length: int
-            The number of bytes to be read from the socket
-
-        Returns
-        -------
-        bytes
-        """
-        if not isinstance(length, int):
-            raise TypeError(f'{length} should be an integer, not a {type(length)}')
-
-        mess_length = 0
-        data_bytes = b''
-        while mess_length < length:
-            if mess_length < length - 4096:
-                data_bytes_tmp = self.socket.recv(4096)
-            else:
-                data_bytes_tmp = self.socket.recv(length - mess_length)
-            mess_length += len(data_bytes_tmp)
-            data_bytes += data_bytes_tmp
-        # print(data_bytes)
-        return data_bytes
-
-    def get_first_nbytes(self, length: int) -> bytes:
-        """ Read the first N bytes from the socket
-
-        Parameters
-        ----------
-        length: int
-            The number of bytes to be read from the socket
-
-        Returns
-        -------
-        bytes: the read bytes string
-        """
-        return self.check_received_length(length)
+from pymodaq_utils.utils import deprecation_msg
 
+deprecation_msg('Importing Socket from pymodaq is deprecated in PyMoDAQ >= 5,'
+                'import it from pymodaq_data.serialize.mysocket')