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

pymodaq/control_modules/move_utility_classes.py

@@ -1,7 +1,8 @@
 import numbers
 
+from abc import abstractmethod
 from time import perf_counter
-from typing import Union, List, Dict, TYPE_CHECKING, Optional
+from typing import Union, List, Dict, TYPE_CHECKING, Optional, TypeVar
 from numbers import Number
 from collections.abc import Iterable
 
@@ -34,11 +35,19 @@ from pymodaq_utils.serialize.serializer_legacy import DeSerializer, Serializer
 from pymodaq import Unit
 from pint.errors import OffsetUnitCalculusError
 
+from pymodaq.control_modules.thread_commands import ThreadStatus, ThreadStatusMove
+from pymodaq.utils.config import Config as ControlModulesConfig
+from pymodaq.control_modules.daq_move_ui.factory import ActuatorUIFactory
+
 if TYPE_CHECKING:
     from pymodaq.control_modules.daq_move import DAQ_Move_Hardware
 
 logger = set_logger(get_module_name(__file__))
-config = configmod.Config()
+
+config_utils = configmod.Config()
+config = ControlModulesConfig()
+
+HardwareController = TypeVar("HardwareController")
 
 
 def check_units(dwa: DataActuator, units: str):
@@ -115,6 +124,7 @@ class MoveCommand:
         the value the move should reach
 
     """
+
     def __init__(self, move_type, value=0):
         if move_type not in MOVE_COMMANDS:
             raise ValueError(f'The allowed move types fro an actuator are {MOVE_COMMANDS}')
@@ -126,7 +136,6 @@ def comon_parameters_fun(is_multiaxes=False, axes_names=None,
                          axis_names: Union[List, Dict] = [],
                          master=True,
                          epsilon: float = config('actuator', 'epsilon_default')):
-
     """Function returning the common and mandatory parameters that should be on the actuator plugin level
 
     Parameters
@@ -166,7 +175,7 @@ def comon_parameters_fun(is_multiaxes=False, axes_names=None,
                       'default': 0},
                      {'title': 'Status:', 'name': 'multi_status', 'type': 'list',
                       'value': 'Master' if master else 'Slave', 'limits': ['Master', 'Slave']},
-                     {'title': 'Axis:', 'name': 'axis', 'type': 'list', 'limits': axis_names,
+                     {'title': 'Axis:', 'name': 'axis', 'type': 'list', 'limits': axis_names.copy(),
                       'value': axis_name},
                  ]},
              ] + comon_parameters(epsilon)
@@ -177,18 +186,22 @@ params = [
     {'title': 'Main Settings:', 'name': 'main_settings', 'type': 'group', 'children': [
         {'title': 'Actuator type:', 'name': 'move_type', 'type': 'str', 'value': '', 'readonly': True},
         {'title': 'Actuator name:', 'name': 'module_name', 'type': 'str', 'value': '', 'readonly': True},
+        {'title': 'UI type:', 'name': 'ui_type', 'type': 'list',
+         'value': config('actuator', 'ui') if config('actuator', 'ui') in ActuatorUIFactory.keys() else
+         ActuatorUIFactory.keys()[0],
+         'limits': ActuatorUIFactory.keys()},
         {'title': 'Plugin Config:', 'name': 'plugin_config', 'type': 'bool_push', 'label': 'Show Config', },
 
         {'title': 'Refresh value (ms):', 'name': 'refresh_timeout', 'type': 'int',
-            'value': config('actuator', 'refresh_timeout_ms')},
+         'value': config('actuator', 'refresh_timeout_ms')},
         {'title': 'TCP/IP options:', 'name': 'tcpip', 'type': 'group', 'visible': True, 'expanded': False,
          'children': [
              {'title': 'Connect to server:', 'name': 'connect_server', 'type': 'bool_push', 'label': 'Connect',
               'value': False},
              {'title': 'Connected?:', 'name': 'tcp_connected', 'type': 'led', 'value': False},
              {'title': 'IP address:', 'name': 'ip_address', 'type': 'str',
-              'value': config('network', 'tcp-server', 'ip')},
-             {'title': 'Port:', 'name': 'port', 'type': 'int', 'value': config('network', 'tcp-server', 'port')},
+              'value': config_utils('network', 'tcp-server', 'ip')},
+             {'title': 'Port:', 'name': 'port', 'type': 'int', 'value': config_utils('network', 'tcp-server', 'port')},
          ]},
         {'title': 'LECO options:', 'name': 'leco', 'type': 'group', 'visible': True, 'expanded': False,
          'children': [
@@ -196,8 +209,9 @@ params = [
               'value': False},
              {'title': 'Connected?:', 'name': 'leco_connected', 'type': 'led', 'value': False},
              {'title': 'Name', 'name': 'leco_name', 'type': 'str', 'value': "", 'default': ""},
-             {'title': 'Host:', 'name': 'host', 'type': 'str', 'value': config('network', "leco-server", "host"), "default": "localhost"},
-             {'title': 'Port:', 'name': 'port', 'type': 'int', 'value': config('network', 'leco-server', 'port')},
+             {'title': 'Host:', 'name': 'host', 'type': 'str', 'value': config_utils('network', "leco-server", "host"),
+              "default": "localhost"},
+             {'title': 'Port:', 'name': 'port', 'type': 'int', 'value': config_utils('network', 'leco-server', 'port')},
          ]},
     ]},
     {'title': 'Actuator Settings:', 'name': 'move_settings', 'type': 'group'}
@@ -274,14 +288,14 @@ class DAQ_Move_base(QObject):
     _epsilons: Union[float, List[float], Dict[str, float]] = None
     _epsilon = 1.0  # deprecated
 
-
     params = []
 
     data_actuator_type = DataActuatorType.float
-    data_shape = (1, )  # expected shape of the underlying actuator's value (in general a float so shape = (1, ))
+    data_shape = (1,)  # expected shape of the underlying actuator's value (in general a float so shape = (1, ))
 
     def __init__(self, parent: Optional['DAQ_Move_Hardware'] = None,
-                 params_state: Optional[dict] = None):
+                 params_state: Optional[dict] = None,
+                 **kwargs):
         QObject.__init__(self)  # to make sure this is the parent class
         self.move_is_done = False
         self.parent = parent
@@ -307,7 +321,10 @@ class DAQ_Move_base(QObject):
             self._title = "myactuator"
 
         self._axis_units: Union[Dict[str, str], List[str]] = None
-        self.axis_units = self._controller_units
+        if isinstance(self._controller_units, str):
+            self.axis_units = self._controller_units
+        else:
+            self.axis_units = self._controller_units.copy()
         if self._epsilons is None:
             self._epsilons = self._epsilon
         self.epsilons = self._epsilons
@@ -341,7 +358,7 @@ class DAQ_Move_base(QObject):
     def axis_unit(self, unit: str):
         self.axis_units[self.axis_index_key] = unit
         self.settings.child('units').setValue(unit)
-        self.emit_status(ThreadCommand('units', unit))
+        self.emit_status(ThreadCommand(ThreadStatusMove.UNITS, unit))
 
     @property
     def axis_units(self) -> Union[List[str], Dict[str, str]]:
@@ -436,6 +453,8 @@ class DAQ_Move_base(QObject):
             return self.settings['multiaxes', 'axis']
         elif isinstance(limits, dict):
             return find_keys_from_val(limits, val=self.settings['multiaxes', 'axis'])[0]
+        else:
+            return ''
 
     @axis_name.setter
     def axis_name(self, name: str):
@@ -495,7 +514,12 @@ class DAQ_Move_base(QObject):
         """ To be subclassed, in order to init specific attributes needed by the real implementation"""
         self.controller = None
 
-    def ini_stage_init(self, old_controller=None, new_controller=None, slave_controller=None):
+    def ini_stage_init(
+        self,
+        old_controller: Optional[HardwareController] = None,
+        new_controller: Optional[HardwareController] = None,
+        slave_controller: Optional[HardwareController] = None,
+    ) -> Optional[HardwareController]:
         """Manage the Master/Slave controller issue
 
         First initialize the status dictionary
@@ -624,35 +648,36 @@ class DAQ_Move_base(QObject):
                     position = self.settings['bounds', 'min_bound']
         return position
 
+    @abstractmethod
     def get_actuator_value(self):
         if hasattr(self, 'check_position'):
             deprecation_msg('check_position method in plugins is deprecated, use get_actuator_value',3)
-            return self.check_position()
+            return self.check_position()  # type: ignore
         else:
             raise NotImplementedError
 
-
-    def close(self):
+    @abstractmethod
+    def close(self) -> None:
         raise NotImplementedError
 
     def move_abs(self, value: Union[float, DataActuator]):
         if hasattr(self, 'move_Abs'):
             deprecation_msg('move_Abs method in plugins is deprecated, use move_abs', 3)
-            self.move_Abs(value)
+            self.move_Abs(value)  # type: ignore
         else:
             raise NotImplementedError
 
     def move_rel(self, value: Union[float, DataActuator]):
         if hasattr(self, 'move_Rel'):
             deprecation_msg('move_Rel method in plugins is deprecated, use move_rel', 3)
-            self.move_Rel(value)
+            self.move_Rel(value)  # type: ignore
         else:
             raise NotImplementedError
 
     def move_home(self, value: Union[float, DataActuator]):
         if hasattr(self, 'move_Home'):
             deprecation_msg('move_Home method in plugins is deprecated, use move_home', 3)
-            self.move_Home()
+            self.move_Home()  # type: ignore
         else:
             raise NotImplementedError
 
@@ -668,7 +693,7 @@ class DAQ_Move_base(QObject):
     def emit_value(self, pos: DataActuator):
         """Convenience method to emit the current actuator value back to the UI"""
 
-        self.emit_status(ThreadCommand('get_actuator_value', [pos]))
+        self.emit_status(ThreadCommand(ThreadStatusMove.GET_ACTUATOR_VALUE, pos))
 
     def commit_settings(self, param: Parameter):
         """
@@ -678,7 +703,8 @@ class DAQ_Move_base(QObject):
     def commit_common_settings(self, param):
         pass
 
-    def move_done(self, position: Optional[DataActuator] = None):  # the position argument is just there to match some signature of child classes
+    def move_done(self, position: Optional[
+        DataActuator] = None):  # the position argument is just there to match some signature of child classes
         """
             | Emit a move done signal transmitting the float position to hardware.
             | The position argument is just there to match some signature of child classes.
@@ -709,7 +735,8 @@ class DAQ_Move_base(QObject):
         --------
         DAQ_utils.ThreadCommand, move_done
         """
-        if 'TCPServer' not in self.__class__.__name__:
+        if not ('TCPServer' in self.__class__.__name__ or
+                'LECODirector' in self.__class__.__name__):
             self.start_time = perf_counter()
             if self.ispolling:
                 self.poll_timer.start()
@@ -729,7 +756,24 @@ class DAQ_Move_base(QObject):
                 logger.debug(f'Current position: {self._current_value}')
                 self.move_done(self._current_value)
 
-    def _condition_to_reach_target(self) -> bool:
+    def _condition_to_reach_target(self, check_absolute_difference=True,) -> bool:
+        """Implement the condition for exiting the polling mechanism and specifying that the
+        target value has been reached
+
+        Returns
+        -------
+        bool: if True, PyMoDAQ considers the target value has been reached
+        See Also
+        --------
+        absolute_difference_condition_to_reach_target
+        user_condition_to_reach_target
+        """
+        cond = True
+        if check_absolute_difference:
+            cond = self.absolute_difference_condition_to_reach_target()            
+        return cond and self.user_condition_to_reach_target()
+
+    def absolute_difference_condition_to_reach_target(self) -> bool:
         """ Implement the condition for exiting the polling mechanism and specifying that the
         target value has been reached
 
@@ -756,7 +800,7 @@ class DAQ_Move_base(QObject):
             else:
                 raise e
 
-        return (epsilon_calculated < self.epsilon) and self.user_condition_to_reach_target()
+        return (epsilon_calculated < self.epsilon)
 
     def user_condition_to_reach_target(self) -> bool:
         """ Implement a user defined condition for exiting the polling mechanism and specifying
@@ -779,7 +823,7 @@ class DAQ_Move_base(QObject):
 
             logger.debug(f'Check move_is_done: {self.move_is_done}')
             if self.move_is_done:
-                self.emit_status(ThreadCommand('Move has been stopped', ))
+                self.emit_status(ThreadCommand(ThreadStatus.UPDATE_STATUS, 'Move has been stopped', ))
                 logger.info('Move has been stopped')
             self.current_value = self.get_actuator_value()
             self.emit_value(self._current_value)
@@ -787,7 +831,7 @@ class DAQ_Move_base(QObject):
 
             if perf_counter() - self.start_time >= self.settings['timeout']:
                 self.poll_timer.stop()
-                self.emit_status(ThreadCommand('raise_timeout', ))
+                self.emit_status(ThreadCommand(ThreadStatus.RAISE_TIMEOUT, ))
                 logger.info('Timeout activated')
         else:
             self.poll_timer.stop()
@@ -804,17 +848,19 @@ class DAQ_Move_base(QObject):
         for param, change, data in changes:
             path = self.settings.childPath(param)
             if change == 'childAdded':
-                self.emit_status(ThreadCommand('update_settings',
+                self.emit_status(ThreadCommand(ThreadStatus.UPDATE_SETTINGS,
                                                [self.parent_parameters_path + path, [data[0].saveState(), data[1]],
                                                 change]))  # send parameters values/limits back to the GUI. Send kind of a copy back the GUI otherwise the child reference will be the same in both th eUI and the plugin so one of them will be removed
             elif change == 'value' or change == 'limits' or change == 'options':
-                self.emit_status(ThreadCommand('update_settings', [self.parent_parameters_path + path, data,
-                                                                   change]))  # send parameters values/limits back to the GUI
+                self.emit_status(ThreadCommand(ThreadStatus.UPDATE_SETTINGS,
+                                               [self.parent_parameters_path + path, data,
+                                                change]))  # send parameters values/limits back to the GUI
             elif change == 'parent':
                 pass
             elif change == 'limits':
-                self.emit_status(ThreadCommand('update_settings', [self.parent_parameters_path + path, data,
-                                                                   change]))
+                self.emit_status(ThreadCommand(ThreadStatus.UPDATE_SETTINGS,
+                                               [self.parent_parameters_path + path, data,
+                                                change]))
 
     def get_position_with_scaling(self, pos: DataActuator) -> DataActuator:
         """ Get the current position from the hardware with scaling conversion.
@@ -868,12 +914,14 @@ class DAQ_Move_base(QObject):
             except ValueError:
                 apply_settings = False
         elif change == 'parent':
-            children = putils.get_param_from_name(self.settings, param.name())
-
-            if children is not None:
-                path = putils.get_param_path(children)
-                self.settings.child(*path[1:-1]).removeChild(children)
+            try:
+                children = putils.get_param_from_name(self.settings, param.name())
 
+                if children is not None:
+                    path = putils.get_param_path(children)
+                    self.settings.child(*path[1:-1]).removeChild(children)
+            except IndexError:
+                logger.debug(f'Could not remove children from {param.name()}')
         self.settings.sigTreeStateChanged.connect(self.send_param_status)
         if apply_settings:
             self.commit_common_settings(param)
@@ -884,6 +932,29 @@ class DAQ_Move_base(QObject):
             elif param.name() == 'epsilon':
                 self.epsilon = param.value()
 
+    # abstract methods to be overwritten by the concrete implementations
+    @abstractmethod
+    def ini_stage(self, controller: Optional[HardwareController] = None) -> tuple[str, bool]:
+        """Actuator communication initialization
+
+        Parameters
+        ----------
+        controller: (object)
+            custom object of a PyMoDAQ plugin (Slave case). None if only one actuator by controller (Master case)
+
+        Returns
+        -------
+        info: str
+        initialized: bool
+            False if initialization failed otherwise True
+        """
+        pass
+
+    @abstractmethod
+    def stop_motion(self, value: DataActuator) -> None:
+        """Stop the actuator and emit move_done signal."""
+        pass
+
 
 class DAQ_Move_TCP_server(DAQ_Move_base, TCPServer):
     """
@@ -933,20 +1004,21 @@ class DAQ_Move_TCP_server(DAQ_Move_base, TCPServer):
 
                 pos = self.get_position_with_scaling(pos)
                 self._current_value = pos
-                self.emit_status(ThreadCommand('get_actuator_value', pos))
+                self.emit_status(ThreadCommand(ThreadStatusMove.GET_ACTUATOR_VALUE, pos))
 
             elif command == 'move_done':
                 pos = DeSerializer(sock).dwa_deserialization()
                 pos = self.get_position_with_scaling(pos)
                 self._current_value = pos
-                self.emit_status(ThreadCommand('move_done', pos))
+                self.emit_status(ThreadCommand(ThreadStatusMove.MOVE_DONE, pos))
             else:
                 self.send_command(sock, command)
 
     def commit_settings(self, param):
 
         if param.name() in putils.iter_children(self.settings.child('settings_client'), []):
-            actuator_socket: Socket = [client['socket'] for client in self.connected_clients if client['type'] == 'ACTUATOR'][0]
+            actuator_socket: Socket = \
+            [client['socket'] for client in self.connected_clients if client['type'] == 'ACTUATOR'][0]
             actuator_socket.check_sended_with_serializer('set_info')
             path = putils.get_param_path(param)[2:]
             # get the path of this param as a list starting at parent 'infos'

pymodaq/control_modules/thread_commands.py

@@ -0,0 +1,137 @@
+from pymodaq_utils.enums import StrEnum
+
+
+class ThreadStatus(StrEnum):
+    """ Allowed Generic commands sent from a plugin using the method: emit_status
+
+    Valid both for DAQ_Move and DAQ_Viewer control modules
+
+    See Also
+    --------
+    ControlModule.thread_status
+    """
+    UPDATE_STATUS = 'update_status'
+    CLOSE = 'close'
+    UPDATE_SETTINGS = 'update_settings'
+    UPDATE_MAIN_SETTINGS = 'update_main_settings'
+    UPDATE_UI = 'update_ui'
+    RAISE_TIMEOUT = 'raise_timeout'
+    SHOW_SPLASH = 'show_splash'
+    CLOSE_SPLASH = 'close_splash'
+
+
+class ThreadStatusMove(StrEnum):
+    """ Allowed Generic commands sent from a plugin using the method: emit_status
+
+    Valid only for DAQ_Move control module
+
+    See Also
+    --------
+    DAQ_Move.thread_status
+    """
+    INI_STAGE = 'ini_stage'
+    GET_ACTUATOR_VALUE = 'get_actuator_value'
+    MOVE_DONE = 'move_done'
+    OUT_OF_BOUNDS = 'outofbounds'
+    SET_ALLOWED_VALUES = 'set_allowed_values'
+    STOP = 'stop'
+    UNITS = 'units'
+
+
+class ThreadStatusViewer(StrEnum):
+    """ Allowed Generic commands sent from a plugin using the method: emit_status
+
+    Valid only for DAQ_Viewer control module
+
+    See Also
+    --------
+    DAQ_Viewer.thread_status
+    """
+    INI_DETECTOR = 'ini_detector'
+    GRAB = 'grab'
+    GRAB_STOPPED = 'grab_stopped'
+    INI_LCD = 'init_lcd'
+    LCD = 'lcd'
+    STOP = 'stop'
+    UPDATE_CHANNELS = 'update_channels'
+
+
+
+class ControlToHardwareMove(StrEnum):
+    """ Allowed commands sent from a DAQ_Move to its DAQ_Move_Hardware in another thread
+     using the method: command_hardware
+
+    Valid only for DAQ_Move command_hardware commands
+
+    """
+    INI_STAGE = 'ini_stage'
+    STOP_MOTION = 'stop_motion'
+    RESET_STOP_MOTION = 'reset_stop_motion'
+    MOVE_ABS = 'move_abs'
+    MOVE_REL = 'move_rel'
+    MOVE_HOME = 'move_home'
+    GET_ACTUATOR_VALUE = 'get_actuator_value'
+    CLOSE = 'close'
+
+class ControlToHardwareViewer(StrEnum):
+    """ Allowed commands sent from a DAQ_Viewer to its DAQ_Detector in another thread
+     using the method: command_hardware
+
+    Valid only for DAQ_Viewer command_hardware commands
+
+    """
+    INI_DETECTOR = 'ini_detector'
+
+    SINGLE = 'single'
+    GRAB = 'grab'
+    STOP_GRAB = 'stop_grab'
+    ROI_SELECT = 'roi_select'
+    UPDATE_SCANNER = 'update_scanner'  # may be deprecated
+    CROSSHAIR = 'crosshair'
+    UPDATE_WAIT_TIME = 'update_wait_time'
+    CLOSE = 'close'
+
+
+class UiToMainMove(StrEnum):
+    """ Allowed Commands to be sent from the DAQ_Move_UI to the DAQ_Move
+    """
+    INIT = 'init'
+    QUIT = 'quit'
+    SHOW_LOG = 'show_log'
+    SHOW_CONFIG = 'show_config'
+    STOP = 'stop'
+
+    MOVE_ABS = 'move_abs'
+    MOVE_REL = 'move_rel'
+
+    ACTUATOR_CHANGED = 'actuator_changed'
+
+    GET_VALUE = 'get_value'
+
+    FIND_HOME = 'find_home'
+    REL_VALUE = 'rel_value'
+
+    LOOP_GET_VALUE = 'loop_get_value'
+
+
+class UiToMainViewer(StrEnum):
+    """ Allowed Commands to be sent from the DAQ_Viewer_UI to the DAQ_Viewer
+    """
+    INIT = 'init'
+    QUIT = 'quit'
+    SHOW_LOG = 'show_log'
+    SHOW_CONFIG = 'show_config'
+    STOP = 'stop'
+
+    SNAP = 'snap'
+    GRAB = 'grab'
+    SAVE_CURRENT = 'save_current'
+    SAVE_NEW = 'save_new'
+    OPEN = 'open'
+
+    DETECTOR_CHANGED = 'detector_changed'
+    VIEWERS_CHANGED = 'viewers_changed'
+    DAQ_TYPE_CHANGED = 'daq_type_changed'
+
+    DO_BKG = 'do_bkg'
+    TAKE_BKG = 'take_bkg'

pymodaq/control_modules/ui_utils.py

@@ -0,0 +1,72 @@
+from importlib import import_module
+from pathlib import Path
+
+from qtpy import QtCore
+
+
+from pymodaq_gui.utils import CustomApp
+
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_utils.config import Config as ConfigUtils
+from pymodaq.utils.config import Config
+
+config_utils = ConfigUtils()
+config = Config()
+
+
+class ControlModuleUI(CustomApp):
+    """ Base Class for ControlModules UIs
+
+    Attributes
+    ----------
+    command_sig: Signal[Threadcommand]
+        This signal is emitted whenever some actions done by the user has to be
+        applied on the main module. Possible commands are:
+        See specific implementation
+
+    See Also
+    --------
+    :class:`daq_move_ui.DAQ_Move_UI`, :class:`daq_viewer_ui.DAQ_Viewer_UI`
+    """
+    command_sig = QtCore.Signal(ThreadCommand)
+
+    def __init__(self, parent):
+        super().__init__(parent)
+        self.config = config
+
+    def display_status(self, txt, wait_time=config_utils('general', 'message_status_persistence')):
+        if self.statusbar is not None:
+            self.statusbar.showMessage(txt, wait_time)
+
+    def do_init(self, do_init=True):
+        """Programmatically press the Init button
+        API entry
+        Parameters
+        ----------
+        do_init: bool
+            will fire the Init button depending on the argument value and the button check state
+        """
+        raise NotImplementedError
+
+    def send_init(self, checked: bool):
+        """Should be implemented to send to the main app the fact that someone (un)checked init."""
+        raise NotImplementedError
+
+
+def register_uis(parent_module_name: str = 'pymodaq.control_modules.daq_move_ui'):
+    uis = []
+    try:
+        scanner_module = import_module(f'{parent_module_name}.uis')
+
+        scanner_path = Path(scanner_module.__path__[0])
+
+        for file in scanner_path.iterdir():
+            if file.is_file() and 'py' in file.suffix and file.stem != '__init__':
+                try:
+                    uis.append(import_module(f'.{file.stem}', scanner_module.__name__))
+                except (ModuleNotFoundError, Exception) as e:
+                    pass
+    except ModuleNotFoundError:
+        pass
+    finally:
+        return uis