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

pymodaq/control_modules/utils.py

@@ -5,28 +5,30 @@ 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
+from pymodaq.utils.config import Config as ControlModulesConfig
 
 
 class DAQTypesEnum(BaseEnum):
@@ -77,7 +79,8 @@ if len(DET_TYPES['DAQ0D']) == 0:
     raise DetectorError('No installed Detector')
 
 
-config = Config()
+config_utils = Config()
+config = ControlModulesConfig()
 logger = set_logger(get_module_name(__file__))
 
 
@@ -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_utils('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))
 
@@ -161,25 +203,23 @@ class ControlModule(QObject):
         """
 
         if status.command == "Update_Status":
+            # legacy
             if len(status.attribute) > 1:
                 self.update_status(status.attribute[0], log=status.attribute[1])
             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 +227,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 +239,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 +267,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 +276,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)
 
@@ -328,9 +368,9 @@ class ControlModule(QObject):
             config_tree = TreeFromToml(config)
             config_tree.show_dialog()
 
-            return Config()
+            return ControlModulesConfig()
 
-    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 +471,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
@@ -469,17 +511,29 @@ class ParameterControlModule(ParameterManager, ControlModule):
             name = self.settings.child("main_settings", "leco", "leco_name").setValue(name)
         return name
 
+    def get_leco_host_port(self) -> tuple:
+        host = self.settings["main_settings", "leco", "host"]
+        port = self.settings["main_settings", "leco", "port"]
+        if host == '':
+            # take the localhost as default
+            host = 'localhost'
+        if port == '':
+            # take the default port as 12300
+            port = 12300
+        return (host, port)    
+
     def connect_leco(self, connect: bool) -> None:
         if connect:
             name = self.get_leco_name()
+            host, port = self.get_leco_host_port()
             try:
                 self._leco_client.name = name
             except AttributeError:
-                self._leco_client = self.listener_class(name=name)
+                self._leco_client = self.listener_class(name=name, host=host, port=port)
                 self._leco_client.cmd_signal.connect(self.process_tcpip_cmds)
             self._command_tcpip[ThreadCommand].connect(self._leco_client.queue_command)
             self._leco_client.start_listen()
-            # self._leco_client.cmd_signal.emit(ThreadCommand("set_info", attribute=["detector_settings", ""]))
+            # self._leco_client.cmd_signal.emit(ThreadCommand(LECOCommands.SET_INFO, attribute=["detector_settings", ""]))
         else:
             self._command_tcpip.emit(ThreadCommand(LECOCommands.QUIT, ))
             try:
@@ -504,45 +558,35 @@ class ParameterControlModule(ParameterManager, ControlModule):
         elif status.command == 'Update_Status':
             self.thread_status(status)
 
-        else:
-            # not handled
-            return status
-
-
-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
+        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)
 
-    See Also
-    --------
-    :class:`daq_move_ui.DAQ_Move_UI`, :class:`daq_viewer_ui.DAQ_Viewer_UI`
-    """
-    command_sig = QtCore.Signal(ThreadCommand)
+            param.setValue(status.attribute.parameter.value())
 
-    def __init__(self, parent):
-        super().__init__(parent)
-        self.config = config
+        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_DIRECTOR_SETTINGS,
+                              ioxml.parameter_to_xml_string(
+                                  self.settings.child(common_param))))
 
-    def display_status(self, txt, wait_time=config('general', 'message_status_persistence')):
-        if self.statusbar is not None:
-            self.statusbar.showMessage(txt, wait_time)
+        else:
+            # not handled
+            return status
 
-    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

pymodaq/control_modules/viewer_utility_classes.py

@@ -1,3 +1,4 @@
+from abc import abstractmethod
 from typing import Union, Iterable
 from qtpy import QtWidgets
 from qtpy.QtCore import QObject, Slot, Signal
@@ -18,7 +19,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',
@@ -267,6 +268,7 @@ class DAQ_Viewer_base(QObject):
         self.controller = controller
         return controller
 
+    @abstractmethod
     def ini_detector(self, controller=None):
         """
         Mandatory
@@ -274,6 +276,7 @@ class DAQ_Viewer_base(QObject):
         """
         raise NotImplementedError
 
+    @abstractmethod
     def close(self):
         """
         Mandatory
@@ -281,6 +284,7 @@ class DAQ_Viewer_base(QObject):
         """
         raise NotImplementedError
 
+    @abstractmethod
     def grab_data(self, Naverage=1, **kwargs):
         """
         Mandatory
@@ -288,6 +292,7 @@ class DAQ_Viewer_base(QObject):
         """
         raise NotImplementedError
 
+    @abstractmethod
     def stop(self):
         """
         Mandatory
@@ -328,15 +333,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 +396,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 +418,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 +540,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 +636,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):
         """