pymodaq 5.0.4__py3-none-any.whl → 5.1.0a0__py3-none-any.whl

pymodaq/control_modules/move_utility_classes.py

@@ -10,6 +10,7 @@ import numpy as np
 from qtpy import QtWidgets
 from qtpy.QtCore import QObject, Slot, Signal, QTimer
 
+
 from pymodaq_utils.utils import ThreadCommand, find_keys_from_val
 from pymodaq_utils import config as configmod
 from pymodaq_utils.warnings import deprecation_msg
@@ -34,6 +35,8 @@ 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
+
 if TYPE_CHECKING:
     from pymodaq.control_modules.daq_move import DAQ_Move_Hardware
 
@@ -281,7 +284,8 @@ class DAQ_Move_base(QObject):
     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
@@ -341,7 +345,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]]:
@@ -610,7 +614,7 @@ class DAQ_Move_base(QObject):
             for data_array in position:
                 data_array[data_array > self.settings['bounds', 'max_bound']] = self.settings['bounds', 'max_bound']
                 data_array[data_array < self.settings['bounds', 'min_bound']] = self.settings['bounds', 'min_bound']
-            self.emit_status(ThreadCommand('outofbounds', []))
+            self.emit_status(ThreadCommand(ThreadStatusMove.OUT_OF_BOUNDS, []))
         return position
 
     def get_actuator_value(self):
@@ -657,7 +661,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):
         """
@@ -698,7 +702,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()
@@ -768,7 +773,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)
@@ -776,7 +781,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()
@@ -793,17 +798,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.
@@ -850,12 +857,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)
@@ -915,13 +924,13 @@ 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)
 

pymodaq/control_modules/thread_commands.py

@@ -0,0 +1,138 @@
+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'
+    STOP_ALL = 'stop_all'
+    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/utils.py

@@ -5,28 +5,31 @@ Created the 03/10/2022
 @author: Sebastien Weber
 """
 from random import randint
-from typing import Optional, Type
-
+from typing import Optional, Type, Union
 from easydict import EasyDict as edict
 
 from qtpy import QtCore
 from qtpy.QtCore import Signal, QObject, Qt, Slot, QThread
 
+from pymodaq.control_modules.thread_commands import ThreadStatus
 from pymodaq_utils.utils import ThreadCommand, find_dict_in_list_from_key_val
 from pymodaq_utils.config import Config
-from pymodaq_utils.enums import BaseEnum, enum_checker
+from pymodaq_utils.enums import BaseEnum
 from pymodaq_utils.logger import get_base_logger, set_logger, get_module_name
 
 from pymodaq_gui.utils.custom_app import CustomApp
 from pymodaq_gui.parameter import Parameter, ioxml
+from pymodaq_gui.parameter.utils import ParameterWithPath
 from pymodaq_gui.managers.parameter_manager import ParameterManager
 from pymodaq_gui.plotting.data_viewers import ViewersEnum
+from pymodaq_gui.h5modules.saving import H5Saver
 
 from pymodaq.utils.tcp_ip.tcp_server_client import TCPClient
 from pymodaq.utils.exceptions import DetectorError
 from pymodaq.utils.leco.pymodaq_listener import ActorListener, LECOClientCommands, LECOCommands
 
 from pymodaq.utils.daq_utils import get_plugins
+from pymodaq.utils.h5modules.module_saving import DetectorSaver, ActuatorSaver
 
 
 class DAQTypesEnum(BaseEnum):
@@ -130,12 +133,51 @@ class ControlModule(QObject):
         self._send_to_tcpip = False
         self._tcpclient_thread = None
         self._hardware_thread = None
-        self.module_and_data_saver = None
+
         self.plugin_config: Optional[Config] = None
 
+        self._h5saver: Optional[H5Saver] = None
+        self._module_and_data_saver = None
+
     def __repr__(self):
         return f'{self.__class__.__name__}: {self.title}'
 
+    def create_new_file(self, new_file: bool):
+        if new_file:
+            self.close_file()
+
+        self.module_and_data_saver.h5saver = self.h5saver
+        return True
+
+    @property
+    def h5saver(self):
+        if self._h5saver is None:
+            self._h5saver = H5Saver(backend=config('general', 'hdf5_backend'))
+        if self._h5saver.h5_file is None:
+            self._h5saver.init_file(update_h5=True)
+        if not self._h5saver.isopen():
+            self._h5saver.init_file(addhoc_file_path=self._h5saver.settings['current_h5_file'])
+        return self._h5saver
+
+    @h5saver.setter
+    def h5saver(self, h5saver_temp: H5Saver):
+        self._h5saver = h5saver_temp
+
+    def close_file(self):
+        self.h5saver.close_file()
+
+    @property
+    def module_and_data_saver(self):
+        if not self._module_and_data_saver.h5saver.isopen():
+            self._module_and_data_saver.h5saver = self.h5saver
+        return self._module_and_data_saver
+
+    @module_and_data_saver.setter
+    def module_and_data_saver(self, mod: Union[DetectorSaver, ActuatorSaver]):
+        self._module_and_data_saver = mod
+        self._module_and_data_saver.h5saver = self.h5saver
+
+
     def custom_command(self, command: str, **kwargs):
         self.command_hardware.emit(ThreadCommand(command, kwargs))
 
@@ -166,20 +208,17 @@ class ControlModule(QObject):
             else:
                 self.update_status(status.attribute[0])
 
-        elif status.command == 'update_status':
+        elif status.command == ThreadStatus.UPDATE_STATUS:
             self.update_status(status.attribute)
 
-        elif status.command == "close":
+        elif status.command == ThreadStatus.CLOSE:
             try:
                 self.update_status(status.attribute[0])
                 self._hardware_thread.quit()
-                self._hardware_thread.wait()
-                finished = self._hardware_thread.isFinished()
-                if finished:
-                    pass
-                else:
-                    print('Thread still running')
+                terminated = self._hardware_thread.wait(5000)
+                if not terminated:
                     self._hardware_thread.terminate()
+                    self._hardware_thread.wait()
                     self.update_status('thread is locked?!', 'log')
             except Exception as e:
                 logger.exception(f'Wrong call to the "close" command: \n{str(e)}')
@@ -187,7 +226,7 @@ class ControlModule(QObject):
             self._initialized_state = False
             self.init_signal.emit(self._initialized_state)
 
-        elif status.command == 'update_main_settings':
+        elif status.command == ThreadStatus.UPDATE_MAIN_SETTINGS:
             # this is a way for the plugins to update main settings of the ui (solely values, limits and options)
             try:
                 if status.attribute[2] == 'value':
@@ -199,7 +238,7 @@ class ControlModule(QObject):
             except Exception as e:
                 logger.exception(f'Wrong call to the "update_main_settings" command: \n{str(e)}')
 
-        elif status.command == 'update_settings':
+        elif status.command == ThreadStatus.UPDATE_SETTINGS:
             # using this the settings shown in the UI for the plugin reflects the real plugin settings
             try:
                 self.settings.sigTreeStateChanged.disconnect(
@@ -227,7 +266,7 @@ class ControlModule(QObject):
                 logger.exception(f'Wrong call to the "update_settings" command: \n{str(e)}')
             self.settings.sigTreeStateChanged.connect(self.parameter_tree_changed)
 
-        elif status.command == 'update_ui':
+        elif status.command == ThreadStatus.UPDATE_UI:
             try:
                 if self.ui is not None:
                     if hasattr(self.ui, status.attribute):
@@ -236,16 +275,16 @@ class ControlModule(QObject):
             except Exception as e:
                 logger.info(f'Wrong call to the "update_ui" command: \n{str(e)}')
 
-        elif status.command == 'raise_timeout':
+        elif status.command == ThreadStatus.RAISE_TIMEOUT:
             self.raise_timeout()
 
-        elif status.command == 'show_splash':
+        elif status.command == ThreadStatus.SHOW_SPLASH:
             self.settings_tree.setEnabled(False)
             self.splash_sc.show()
             self.splash_sc.raise_()
             self.splash_sc.showMessage(status.attribute, color=Qt.white)
 
-        elif status.command == 'close_splash':
+        elif status.command == ThreadStatus.CLOSE_SPLASH:
             self.splash_sc.close()
             self.settings_tree.setEnabled(True)
 
@@ -330,7 +369,7 @@ class ControlModule(QObject):
 
             return Config()
 
-    def update_status(self, txt, log=True):
+    def update_status(self, txt: str, log=True):
         """Display a message in the ui status bar and eventually log the message
 
         Parameters
@@ -431,7 +470,9 @@ class ParameterControlModule(ParameterManager, ControlModule):
                 if self.settings.child('main_settings', 'tcpip', 'tcp_connected').value():
                     self._command_tcpip.emit(ThreadCommand('send_info', dict(path=path, param=param)))
                 if self.settings.child('main_settings', 'leco', 'leco_connected').value():
-                    self._command_tcpip.emit(ThreadCommand('send_info', dict(path=path, param=param)))
+                    self._command_tcpip.emit(
+                        ThreadCommand(LECOCommands.SEND_INFO,
+                                      ParameterWithPath(param, path)))
 
     def connect_tcp_ip(self, params_state=None, client_type: str = "GRABBER") -> None:
         """Init a TCPClient in a separated thread to communicate with a distant TCp/IP Server
@@ -504,6 +545,33 @@ class ParameterControlModule(ParameterManager, ControlModule):
         elif status.command == 'Update_Status':
             self.thread_status(status)
 
+        elif status.command == 'set_info':
+            """ The Director sent a parameter to be updated"""
+            path_in_settings = status.attribute.path
+            if 'move' in self.__class__.__name__.lower():
+                common_param = 'move_settings'
+            else:
+                common_param = 'detector_settings'
+            if common_param in path_in_settings:
+                param = self.settings.child(*path_in_settings)
+            elif 'settings_client' in path_in_settings:
+                param = self.settings.child(common_param, *path_in_settings[1:])
+            else:
+                param = self.settings.child(common_param, *path_in_settings)
+
+            param.setValue(status.attribute.parameter.value())
+
+        elif status.command == LECOCommands.GET_SETTINGS:
+            """ The Director requested the content of the actuator settings"""
+            if 'move' in self.__class__.__name__.lower():
+                common_param = 'move_settings'
+            else:
+                common_param = 'detector_settings'
+            self._command_tcpip.emit(
+                ThreadCommand(LECOCommands.SET_SETTINGS,
+                              ioxml.parameter_to_xml_string(
+                                  self.settings.child(common_param))))
+
         else:
             # not handled
             return status

pymodaq/control_modules/viewer_utility_classes.py

@@ -18,7 +18,7 @@ from pymodaq_utils.warnings import deprecation_msg
 from pymodaq_utils.serialize.mysocket import Socket
 from pymodaq_utils.serialize.serializer_legacy import DeSerializer, Serializer
 from pymodaq_gui.plotting.utils.plot_utils import RoiInfo
-
+from pymodaq.control_modules.thread_commands import ThreadStatus, ThreadStatusViewer
 from pymodaq_gui.utils.utils import mkQApp
 
 comon_parameters = [{'title': 'Controller Status:', 'name': 'controller_status', 'type': 'list',
@@ -328,15 +328,6 @@ class DAQ_Viewer_base(QObject):
         """
         pass
 
-    def get_axis(self):
-        """deprecated"""
-        raise DeprecationWarning('get_axis is deprecated add the axes within the DataWithAxes, '
-                                 'DataFromPlugins')
-        if self.plugin_type == '1D' or self.plugin_type == '2D':
-            self.emit_x_axis()
-
-        if self.plugin_type == '2D':
-            self.emit_y_axis()
 
     def emit_status(self, status: ThreadCommand):
         """
@@ -400,8 +391,7 @@ class DAQ_Viewer_base(QObject):
 
             self.commit_settings(param)
         except Exception as e:
-            self.emit_status(ThreadCommand("Update_Status", [str(e), 'log']))
-
+            self.emit_status(ThreadCommand(ThreadStatus.UPDATE_STATUS, str(e)))
 
 
     def send_param_status(self, param, changes):
@@ -423,13 +413,14 @@ class DAQ_Viewer_base(QObject):
             path = self.settings.childPath(param)
             if change == 'childAdded':
                 # first create a "copy" of the actual parameter and send this "copy", to be restored in the main UI
-                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
 
@@ -544,7 +535,7 @@ class DAQ_Viewer_TCP_server(DAQ_Viewer_base, TCPServer):
                 self.send_data(command_sock, data)  # to be send to a client
 
         except Exception as e:
-            self.emit_status(ThreadCommand("Update_Status", [str(e), 'log']))
+            self.emit_status(ThreadCommand(ThreadStatus.UPDATE_STATUS, str(e)))
 
     def commit_settings(self, param):
 
@@ -640,7 +631,7 @@ class DAQ_Viewer_TCP_server(DAQ_Viewer_base, TCPServer):
             # self.command_server.emit(["process_cmds","Send Data 2D"])
 
         except Exception as e:
-            self.emit_status(ThreadCommand('Update_Status', [getLineInfo() + str(e), "log"]))
+            self.emit_status(ThreadCommand(ThreadStatus.UPDATE_STATUS, str(e)))
 
     def stop(self):
         """