pymodaq 4.1.5__py3-none-any.whl → 4.2.1__py3-none-any.whl

pymodaq/__init__.py

@@ -39,9 +39,10 @@ try:
     # in a try statement for compilation on readthedocs server but if this fail, you cannot use the code
     from pymodaq.utils.plotting import data_viewers  # imported here as to avoid circular imports later on
     from pymodaq.utils.daq_utils import copy_preset, setLocale, set_qt_backend
-
+    from pymodaq.utils.daq_utils import get_instrument_plugins
     from pymodaq.utils.config import Config
-
+    from pymodaq.utils.scanner.utils import register_scanners
+    from pymodaq.utils.plotting.plotter.plotter import register_plotter, PlotterFactory
 
     # issue on windows when using .NET code within multithreads, this below allows it but requires the
     # pywin32 (pythoncom) package
@@ -66,8 +67,8 @@ try:
     logger.info('')
     logger.info('************************')
     logger.info(f"Setting Qt backend to: {config['qtbackend']['backend']} ...")
-    logger.info('************************')
     set_qt_backend()
+    logger.info('************************')
     logger.info('')
     logger.info('')
     logger.info('************************')
@@ -83,8 +84,26 @@ try:
     Q_ = ureg.Quantity
     logger.info('')
     logger.info('')
-    logger.info('************************')
+    logger.info('*************************************************************************')
     logger.info(f"Getting the list of instrument plugins...")
+    logger.info('')
+    get_instrument_plugins()
+    logger.info('*************************************************************************')
+
+    logger.info('')
+    logger.info('')
+    logger.info('************************')
+    logger.info(f"Registering Scanners...")
+    register_scanners()
+    logger.info(f"Done")
+    logger.info('************************')
+
+    logger.info('')
+    logger.info('')
+    logger.info('************************')
+    logger.info(f"Registering plotters...")
+    register_plotter()
+    logger.info(f"Done")
     logger.info('************************')
 
 except Exception as e:

pymodaq/control_modules/daq_move.py

@@ -10,8 +10,9 @@ from __future__ import annotations
 import numbers
 from importlib import import_module
 from numbers import Number
+from random import randint
 import sys
-from typing import List, Tuple, Union
+from typing import List, Tuple, Union, Optional, Type
 import numpy as np
 
 from qtpy.QtCore import QObject, Signal, QThread, Slot, Qt, QTimer
@@ -20,15 +21,12 @@ from qtpy import QtWidgets
 from easydict import EasyDict as edict
 
 from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.control_modules.utils import ControlModule
-from pymodaq.utils.parameter import ioxml
+from pymodaq.control_modules.utils import ParameterControlModule
 from pymodaq.control_modules.daq_move_ui import DAQ_Move_UI, ThreadCommand
-from pymodaq.utils.managers.parameter_manager import ParameterManager, Parameter
 from pymodaq.control_modules.move_utility_classes import MoveCommand, DAQ_Move_base
-from pymodaq.utils.tcp_ip.tcp_server_client import TCPClient
 from pymodaq.control_modules.move_utility_classes import params as daq_move_params
 from pymodaq.utils import daq_utils as utils
-from pymodaq.utils.parameter import utils as putils
+from pymodaq.utils.parameter import Parameter, utils as putils
 from pymodaq.utils.gui_utils import get_splash_sc
 from pymodaq.utils import config as config_mod
 from pymodaq.utils.exceptions import ActuatorError
@@ -37,6 +35,8 @@ from pymodaq.utils.h5modules import module_saving
 from pymodaq.utils.data import DataRaw, DataToExport, DataFromPlugins, DataActuator
 from pymodaq.utils.h5modules.backends import Node
 
+from pymodaq.utils.leco.pymodaq_listener import MoveActorListener, LECOMoveCommands
+
 
 local_path = config_mod.get_set_local_dir()
 sys.path.append(str(local_path))
@@ -52,7 +52,7 @@ if len(ACTUATOR_TYPES) == 0:
 STATUS_WAIT_TIME = 1000
 
 
-class DAQ_Move(ParameterManager, ControlModule):
+class DAQ_Move(ParameterControlModule):
     """ Main PyMoDAQ class to drive actuators
 
     Qt object and generic UI to drive actuators.
@@ -75,12 +75,13 @@ class DAQ_Move(ParameterManager, ControlModule):
 
     move_done_signal = Signal(DataActuator)
     current_value_signal = Signal(DataActuator)
-    _update_settings_signal = Signal(edict)
     bounds_signal = Signal(bool)
 
     params = daq_move_params
 
-    def __init__(self, parent=None, title="DAQ Move"):
+    listener_class = MoveActorListener
+
+    def __init__(self, parent=None, title="DAQ Move", **kwargs):
         """
 
         Parameters
@@ -95,15 +96,13 @@ class DAQ_Move(ParameterManager, ControlModule):
         self.logger = set_logger(f'{logger.name}.{title}')
         self.logger.info(f'Initializing DAQ_Move: {title}')
 
-        QObject.__init__(self)
-        ParameterManager.__init__(self, action_list= ('save', 'update'))
-        ControlModule.__init__(self)
+        super().__init__(action_list=('save', 'update'), **kwargs)
 
         self.parent = parent
         if parent is not None:
             self.ui = DAQ_Move_UI(parent, title)
         else:
-            self.ui: DAQ_Move_UI = None
+            self.ui: Optional[DAQ_Move_UI] = None
 
         if self.ui is not None:
             self.ui.actuators = ACTUATOR_TYPES
@@ -172,7 +171,7 @@ class DAQ_Move(ParameterManager, ControlModule):
         elif cmd.command == 'rel_value':
             self._relative_value = cmd.attribute
 
-    def append_data(self, dte: DataToExport = None, where: Union[Node, str] = None):
+    def append_data(self, dte: Optional[DataToExport] = None, where: Union[Node, str, None] = None):
         """Appends current DataToExport to an ActuatorEnlargeableSaver
 
         Parameters
@@ -374,32 +373,14 @@ class DAQ_Move(ParameterManager, ControlModule):
         """bool: status of the actuator's status (done or not)"""
         return self._move_done_bool
 
-    def value_changed(self, param):
+    def value_changed(self, param: Parameter):
         """ Apply changes of value in the settings"""
-        if param.name() == 'connect_server':
-            if param.value():
-                self.connect_tcp_ip()
-            else:
-                self._command_tcpip.emit(ThreadCommand('quit', ))
-
-        elif param.name() == 'ip_address' or param.name == 'port':
-            self._command_tcpip.emit(
-                ThreadCommand('update_connection', dict(ipaddress=self.settings.child('main_settings', 'tcpip',
-                                                                                      'ip_address').value(),
-                                                        port=self.settings.child('main_settings', 'tcpip',
-                                                                                 'port').value())))
-        elif param.name() == 'refresh_timeout':
-            self._refresh_timer.setInterval(param.value())
+        super().value_changed(param=param)
 
-        elif param.name() == 'plugin_config':
-            self.show_config(self.plugin_config)
+        if param.name() == 'refresh_timeout':
+            self._refresh_timer.setInterval(param.value())
 
-        path = self.settings.childPath(param)
-        if path is not None:
-            if 'main_settings' not in path:
-                self._update_settings_signal.emit(edict(path=path, param=param, change='value'))
-                if self.settings.child('main_settings', 'tcpip', 'tcp_connected').value():
-                    self._command_tcpip.emit(ThreadCommand('send_info', dict(path=path, param=param)))
+        self._update_settings(param=param)
 
     def param_deleted(self, param):
         """ Apply deletion of settings """
@@ -470,6 +451,8 @@ class DAQ_Move(ParameterManager, ControlModule):
             self.current_value_signal.emit(self._current_value)
             if self.settings['main_settings', 'tcpip', 'tcp_connected'] and self._send_to_tcpip:
                 self._command_tcpip.emit(ThreadCommand('position_is', status.attribute))
+            if self.settings['main_settings', 'leco', 'leco_connected'] and self._send_to_tcpip:
+                self._command_tcpip.emit(ThreadCommand(LECOMoveCommands.POSITION, status.attribute))
 
         elif status.command == "move_done":
             data_act: DataActuator = status.attribute[0]
@@ -482,6 +465,8 @@ class DAQ_Move(ParameterManager, ControlModule):
             self.move_done_signal.emit(data_act)
             if self.settings.child('main_settings', 'tcpip', 'tcp_connected').value() and self._send_to_tcpip:
                 self._command_tcpip.emit(ThreadCommand('move_done', status.attribute))
+            if self.settings.child('main_settings', 'leco', 'leco_connected').value() and self._send_to_tcpip:
+                self._command_tcpip.emit(ThreadCommand(LECOMoveCommands.MOVE_DONE, status.attribute))
 
         elif status.command == 'outofbounds':
             self.bounds_signal.emit(True)
@@ -586,23 +571,13 @@ class DAQ_Move(ParameterManager, ControlModule):
             self.logger.exception(str(e))
 
     def connect_tcp_ip(self):
-        if self.settings.child('main_settings', 'tcpip', 'connect_server').value():
-            self._tcpclient_thread = QThread()
-
-            tcpclient = TCPClient(self.settings.child('main_settings', 'tcpip', 'ip_address').value(),
-                                  self.settings.child('main_settings', 'tcpip', 'port').value(),
-                                  self.settings.child('move_settings'), client_type="ACTUATOR")
-            tcpclient.moveToThread(self._tcpclient_thread)
-            self._tcpclient_thread.tcpclient = tcpclient
-            tcpclient.cmd_signal.connect(self.process_tcpip_cmds)
-
-            self._command_tcpip[ThreadCommand].connect(tcpclient.queue_command)
-            self._tcpclient_thread.started.connect(tcpclient.init_connection)
-
-            self._tcpclient_thread.start()
+        super().connect_tcp_ip(params_state=self.settings.child('move_settings'),
+                               client_type="ACTUATOR")
 
     @Slot(ThreadCommand)
-    def process_tcpip_cmds(self, status):
+    def process_tcpip_cmds(self, status: ThreadCommand) -> None:
+        if super().process_tcpip_cmds(status=status) is None:
+            return
         if 'move_abs' in status.command:
             self.move_abs(status.attribute[0], send_to_tcpip=True)
 
@@ -621,22 +596,6 @@ class DAQ_Move(ParameterManager, ControlModule):
             self._send_to_tcpip = True
             self.command_hardware.emit(ThreadCommand('get_actuator_value', ))
 
-        elif status.command == 'connected':
-            self.settings.child('main_settings', 'tcpip', 'tcp_connected').setValue(True)
-
-        elif status.command == 'disconnected':
-            self.settings.child('main_settings', 'tcpip', 'tcp_connected').setValue(False)
-
-        elif status.command == 'Update_Status':
-            self.thread_status(status)
-
-        elif status.command == 'set_info':
-            param_dict = ioxml.XML_string_to_parameter(status.attribute[1])[0]
-            param_tmp = Parameter.create(**param_dict)
-            param = self.settings.child('move_settings', *status.attribute[0][1:])
-
-            param.restoreState(param_tmp.saveState())
-
 
 class DAQ_Move_Hardware(QObject):
     """
@@ -658,10 +617,10 @@ class DAQ_Move_Hardware(QObject):
         super().__init__()
         self.logger = set_logger(f'{logger.name}.{title}.actuator')
         self._title = title
-        self.hardware: DAQ_Move_base = None
+        self.hardware: Optional[DAQ_Move_base] = None
         self.actuator_type = actuator_type
         self.current_position: DataActuator = position
-        self._target_value: DataActuator = None
+        self._target_value: Optional[DataActuator] = None
         self.hardware_adress = None
         self.axis_address = None
         self.motion_stoped = False
@@ -702,7 +661,7 @@ class DAQ_Move_Hardware(QObject):
             =============== =================================== ==========================================================================================================================
             **Parameters**   **Type**                             **Description**
 
-             *params_state*  ordered dictionnary list             The parameter state of the hardware class composed by a list representing the tree to keep a temporary save of the tree
+             *params_state*  ordered dictionary list             The parameter state of the hardware class composed by a list representing the tree to keep a temporary save of the tree
 
              *controller*    one or many instance of DAQ_Move     The controller id of the hardware
 
@@ -878,12 +837,12 @@ class DAQ_Move_Hardware(QObject):
     @Slot(edict)
     def update_settings(self, settings_parameter_dict):
         """
-            Update settings of hardware with dictionnary parameters in case of "Move_Settings" path, else update attribute with dictionnary parameters.
+            Update settings of hardware with dictionary parameters in case of "Move_Settings" path, else update attribute with dictionnary parameters.
 
             =========================  =========== ======================================================
             **Parameters**              **Type**    **Description**
 
-            *settings_parameter_dict*  dictionnary  Dictionnary containing the path and linked parameter
+            *settings_parameter_dict*  dictionary  Dictionary containing the path and linked parameter
             =========================  =========== ======================================================
 
             See Also

pymodaq/control_modules/daq_viewer.py

@@ -10,8 +10,9 @@ from collections import OrderedDict
 import copy
 import os
 from pathlib import Path
+from random import randint
 import sys
-from typing import List, Tuple, Union
+from typing import List, Tuple, Union, Optional
 import time
 
 from easydict import EasyDict as edict
@@ -21,9 +22,8 @@ from qtpy.QtCore import Qt, QObject, Slot, QThread, Signal
 
 from pymodaq.utils.data import DataFromPlugins, DataToExport, Axis, DataDistribution
 from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.control_modules.utils import ControlModule
+from pymodaq.control_modules.utils import ParameterControlModule
 from pymodaq.utils.gui_utils.file_io import select_file
-from pymodaq.utils.tcp_ip.tcp_server_client import TCPClient
 from pymodaq.utils.gui_utils.widgets.lcd import LCD
 from pymodaq.utils.config import Config, get_set_local_dir
 from pymodaq.utils.h5modules.browsing import browse_data
@@ -31,26 +31,28 @@ from pymodaq.utils.h5modules.saving import H5Saver
 from pymodaq.utils.h5modules import module_saving
 from pymodaq.utils.h5modules.backends import Node
 from pymodaq.utils.daq_utils import ThreadCommand
-from pymodaq.utils.parameter import ioxml
+from pymodaq.utils.parameter import ioxml, Parameter
 from pymodaq.utils.parameter import utils as putils
 from pymodaq.control_modules.viewer_utility_classes import params as daq_viewer_params
 from pymodaq.utils import daq_utils as utils
 from pymodaq.utils.messenger import deprecation_msg
 from pymodaq.utils.gui_utils import DockArea, get_splash_sc, Dock
-from pymodaq.utils.managers.parameter_manager import ParameterManager, Parameter
 from pymodaq.control_modules.daq_viewer_ui import DAQ_Viewer_UI
 from pymodaq.control_modules.utils import DET_TYPES, get_viewer_plugins, DAQTypesEnum, DetectorError
-from pymodaq.utils.plotting.data_viewers.viewer import ViewerBase, ViewersEnum
+from pymodaq.utils.plotting.data_viewers.viewer import ViewerBase
+from pymodaq.utils.plotting.data_viewers import ViewersEnum
 from pymodaq.utils.enums import enum_checker
 from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base
 
+from pymodaq.utils.leco.pymodaq_listener import ViewerActorListener, LECOClientCommands
+
 logger = set_logger(get_module_name(__file__))
 config = Config()
 
 local_path = get_set_local_dir()
 
 
-class DAQ_Viewer(ParameterManager, ControlModule):
+class DAQ_Viewer(ParameterControlModule):
     """ Main PyMoDAQ class to drive detectors
 
     Qt object and generic UI to drive actuators. The class is giving you full functionality to select (daq_detector),
@@ -80,26 +82,27 @@ class DAQ_Viewer(ParameterManager, ControlModule):
     create if one want to receive infos from the ROI
     """
     settings_name = 'daq_viewer_settings'
-    custom_sig = Signal(ThreadCommand)  # particular case where DAQ_Viewer  is used for a custom module
+    custom_sig = Signal(ThreadCommand)  # particular case where DAQ_Viewer is used for a custom module
 
     grab_done_signal = Signal(DataToExport)
 
-    _update_settings_signal = Signal(edict)
     overshoot_signal = Signal(bool)
     data_saved = Signal()
     grab_status = Signal(bool)
 
     params = daq_viewer_params
 
+    listener_class = ViewerActorListener
+
     def __init__(self, parent=None, title="Testing",
                  daq_type=config('viewer', 'daq_type'),
-                 dock_settings=None, dock_viewer=None):
+                 dock_settings=None, dock_viewer=None,
+                 **kwargs):
 
         self.logger = set_logger(f'{logger.name}.{title}')
         self.logger.info(f'Initializing DAQ_Viewer: {title}')
 
-        ParameterManager.__init__(self, action_list = ('save','update'))
-        ControlModule.__init__(self)
+        super().__init__(**kwargs)
 
         daq_type = enum_checker(DAQTypesEnum, daq_type)
         self._daq_type: DAQTypesEnum = daq_type
@@ -118,7 +121,7 @@ class DAQ_Viewer(ParameterManager, ControlModule):
                                                    dock_settings=dock_settings,
                                                    dock_viewer=dock_viewer)
         else:
-            self.ui: DAQ_Viewer_UI = None
+            self.ui: Optional[DAQ_Viewer_UI] = None
 
         if self.ui is not None:
             QtWidgets.QApplication.processEvents()
@@ -131,10 +134,11 @@ class DAQ_Viewer(ParameterManager, ControlModule):
 
         self._title = title
 
-        self.module_and_data_saver: Union[module_saving.DetectorSaver,
+        self.module_and_data_saver: Union[None,
+                                          module_saving.DetectorSaver,
                                           module_saving.DetectorEnlargeableSaver,
                                           module_saving.DetectorExtendedSaver] = None
-        self._h5saver_continuous: H5Saver = None
+        self._h5saver_continuous: Optional[H5Saver] = None
         self._ind_continuous_grab = 0
         self.setup_continuous_saving()
 
@@ -154,14 +158,14 @@ class DAQ_Viewer(ParameterManager, ControlModule):
         self._start_grab_time: float = 0.  # used for the refreshing rate
         self._received_data: int = 0
 
-        self._lcd: LCD = None
+        self._lcd: Optional[LCD] = None
 
-        self._bkg: DataToExport = None  # buffer to store background
+        self._bkg: Optional[DataToExport] = None  # buffer to store background
 
-        self._save_file_pathname: Path = None  # to store last active path, will be an Path object
+        self._save_file_pathname: Optional[Path] = None  # to store last active path, will be an Path object
         
-        self._snapshot_pathname: Path = None
-        self._data_to_save_export: DataToExport = None
+        self._snapshot_pathname: Optional[Path] = None
+        self._data_to_save_export: Optional[DataToExport] = None
 
         self._do_save_data: bool = False
 
@@ -370,11 +374,17 @@ class DAQ_Viewer(ParameterManager, ControlModule):
                 viewer.data_to_export_signal.disconnect()
             except:
                 pass
-        for viewer in viewers:
+        for ind_viewer, viewer in enumerate(viewers):
             viewer.data_to_export_signal.connect(self._get_data_from_viewer)
-            if hasattr(viewer, 'ROI_select_signal'):
-                viewer.ROI_select_signal.connect(
-                    lambda roi_pos_size: self.command_hardware.emit(ThreadCommand('ROISelect', roi_pos_size)))
+            #deprecated:
+            viewer.ROI_select_signal.connect(
+                lambda roi_info: self.command_hardware.emit(ThreadCommand('ROISelect', roi_info)))
+            #use that now
+            viewer.roi_select_signal.connect(
+                lambda roi_info: self.command_hardware.emit(
+                    ThreadCommand('roi_select',
+                                  dict(roi_info=roi_info, ind_viewer=ind_viewer))))
+
         self._viewers = viewers
 
     def quit_fun(self):
@@ -661,8 +671,8 @@ class DAQ_Viewer(ParameterManager, ControlModule):
             dte.get_data_from_source('raw')  # filters depending on the source: raw or calculated
 
         dte = DataToExport(name=dte.name, data=  # filters depending on the extra argument 'save'
-                           [dwa for dwa in dte if ('save' not in dwa.extra_attributes) or
-                            ('save' in dwa.extra_attributes and dwa.save)])
+                           [dwa for dwa in dte if ('do_save' not in dwa.extra_attributes) or
+                            ('do_save' in dwa.extra_attributes and dwa.do_save)])
 
         self.module_and_data_saver.add_data(detector_node, dte, **kwargs)
 
@@ -787,7 +797,9 @@ class DAQ_Viewer(ParameterManager, ControlModule):
         """
         try:
             dte = dte.deepcopy()
-            if self.settings.child('main_settings', 'tcpip', 'tcp_connected').value() and self._send_to_tcpip:
+            if self.settings['main_settings', 'tcpip', 'tcp_connected'] and self._send_to_tcpip:
+                self._command_tcpip.emit(ThreadCommand('data_ready', dte))
+            if self.settings['main_settings', 'leco', 'leco_connected'] and self._send_to_tcpip:
                 self._command_tcpip.emit(ThreadCommand('data_ready', dte))
             if self.ui is not None:
                 self.ui.data_ready = True
@@ -818,8 +830,8 @@ class DAQ_Viewer(ParameterManager, ControlModule):
                 refresh = True  # if single
             if self.ui is not None and self.settings.child('main_settings', 'show_data').value() and refresh:
                 self._received_data = 0  # so that data send back from viewers can be properly counted
-                data_to_plot = self._data_to_save_export.get_data_from_attribute('plot', True, deepcopy=True)
-                data_to_plot.append(self._data_to_save_export.get_data_from_missing_attribute('plot', deepcopy=True))
+                data_to_plot = self._data_to_save_export.get_data_from_attribute('do_plot', True, deepcopy=True)
+                data_to_plot.append(self._data_to_save_export.get_data_from_missing_attribute('do_plot', deepcopy=True))
                 # process bkg if needed
                 if self.do_bkg and self._bkg is not None:
                     data_to_plot -= self._bkg
@@ -850,8 +862,8 @@ class DAQ_Viewer(ParameterManager, ControlModule):
         self._process_overshoot(dte)
 
         self._viewer_types = [ViewersEnum(dwa.dim.name) for dwa in dte if
-                              ('plot' not in dwa.extra_attributes) or
-                              ('plot' in dwa.extra_attributes and dwa.plot)]
+                              ('do_plot' not in dwa.extra_attributes) or
+                              ('do_plot' in dwa.extra_attributes and dwa.do_plot)]
         if self.ui is not None:
             if self.ui.viewer_types != self._viewer_types:
                 self.ui.update_viewers(self._viewer_types)
@@ -870,8 +882,8 @@ class DAQ_Viewer(ParameterManager, ControlModule):
         ViewerBase, Viewer0D, Viewer1D, Viewer2D
         """
         for ind, dwa in enumerate(dte):
-            if ('plot' not in dwa.extra_attributes) or \
-                    ('plot' in dwa.extra_attributes and dwa.plot):
+            if ('do_plot' not in dwa.extra_attributes) or \
+                    ('do_plot' in dwa.extra_attributes and dwa.do_plot):
                 self.viewers[ind].title = dwa.name
                 self.viewer_docks[ind].setTitle(self._title + ' ' + dwa.name)
 
@@ -888,6 +900,8 @@ class DAQ_Viewer(ParameterManager, ControlModule):
         param: Parameter
             a given parameter whose value has been changed by user
         """
+        super().value_changed(param=param)
+
         path = self.settings.childPath(param)
         if param.name() == 'DAQ_type':
             self._h5saver_continuous.settings.child('do_save').setValue(False)
@@ -927,27 +941,7 @@ class DAQ_Viewer(ParameterManager, ControlModule):
         elif param.name() == 'wait_time':
             self.command_hardware.emit(ThreadCommand('update_wait_time', [param.value()]))
 
-        elif param.name() == 'connect_server':
-            if param.value():
-                self.connect_tcp_ip()
-            else:
-                self._command_tcpip.emit(ThreadCommand('quit', ))
-
-        elif param.name() == 'ip_address' or param.name == 'port':
-            self._command_tcpip.emit(
-                ThreadCommand('update_connection',
-                              dict(ipaddress=self.settings['main_settings', 'tcpip', 'ip_address'],
-                                   port=self.settings['main_settings', 'tcpip', 'port'])))
-
-        elif param.name() == 'plugin_config':
-            self.show_config(self.plugin_config)
-
-        if path is not None:
-            if 'main_settings' not in path:
-                self._update_settings_signal.emit(edict(path=path, param=param, change='value'))
-
-                if self.settings.child('main_settings', 'tcpip', 'tcp_connected').value():
-                    self._command_tcpip.emit(ThreadCommand('send_info', dict(path=path, param=param)))
+        self._update_settings(param=param)
 
     def child_added(self, param, data):
         """ Adds a child in the settings attribute
@@ -991,6 +985,7 @@ class DAQ_Viewer(ParameterManager, ControlModule):
 
             det_params, _class = get_viewer_plugins(self.daq_type.name, self.detector)
             self.settings.child('detector_settings').addChildren(det_params.children())
+            self.settings.child('main_settings', 'module_name').setValue(self._title)
         except Exception as e:
             self.logger.exception(str(e))
 
@@ -1078,32 +1073,11 @@ class DAQ_Viewer(ParameterManager, ControlModule):
             self.stop_grab()
 
     def connect_tcp_ip(self):
-        """Init a TCPClient in a separated thread to communicate with a distant TCp/IP Server
-
-        Use the settings: ip_address and port to specify the connection
-
-        See Also
-        --------
-        TCPServer
-        """
-        if self.settings.child('main_settings', 'tcpip', 'connect_server').value():
-            self._tcpclient_thread = QThread()
-
-            tcpclient = TCPClient(self.settings.child('main_settings', 'tcpip', 'ip_address').value(),
-                                  self.settings.child('main_settings', 'tcpip', 'port').value(),
-                                  self.settings.child('detector_settings'))
-            tcpclient.moveToThread(self._tcpclient_thread)
-            self._tcpclient_thread.tcpclient = tcpclient
-            tcpclient.cmd_signal.connect(self.process_tcpip_cmds)
-
-            self._command_tcpip[ThreadCommand].connect(tcpclient.queue_command)
-
-            self._tcpclient_thread.started.connect(tcpclient.init_connection)
-
-            self._tcpclient_thread.start()
+        super().connect_tcp_ip(params_state=self.settings.child('detector_settings'),
+                               client_type="GRABBER")
 
     @Slot(ThreadCommand)
-    def process_tcpip_cmds(self, status):
+    def process_tcpip_cmds(self, status: ThreadCommand) -> None:
         """Receive commands from the TCP Server (if connected) and process them
 
         Parameters
@@ -1121,23 +1095,16 @@ class DAQ_Viewer(ParameterManager, ControlModule):
         connect_tcp_ip, TCPServer
 
         """
+        if super().process_tcpip_cmds(status=status) is None:
+            return
         if 'Send Data' in status.command:
             self.snapshot('', send_to_tcpip=True)
-        elif status.command == 'connected':
-            self.settings.child('main_settings', 'tcpip', 'tcp_connected').setValue(True)
 
-        elif status.command == 'disconnected':
-            self.settings.child('main_settings', 'tcpip', 'tcp_connected').setValue(False)
+        elif status.command == LECOClientCommands.LECO_CONNECTED:
+            self.settings.child('main_settings', 'leco', 'leco_connected').setValue(True)
 
-        elif status.command == 'Update_Status':
-            self.thread_status(status)
-
-        elif status.command == 'set_info':
-            param_dict = ioxml.XML_string_to_parameter(status.attribute[1])[0]
-            param_tmp = Parameter.create(**param_dict)
-            param = self.settings.child('detector_settings', *status.attribute[0][1:])
-
-            param.restoreState(param_tmp.saveState())
+        elif status.command == LECOClientCommands.LECO_DISCONNECTED:
+            self.settings.child('main_settings', 'leco', 'leco_connected').setValue(False)
 
         elif status.command == 'get_axis':
             raise DeprecationWarning('Do not use this, the axis are in the data objects')
@@ -1270,7 +1237,12 @@ class DAQ_Detector(QObject):
         else:  # custom commands for particular plugins
             if hasattr(self.detector, command.command):
                 cmd = getattr(self.detector, command.command)
-                cmd(command.attribute)
+                if isinstance(command.attribute, list):
+                    cmd(*command.attribute)
+                elif isinstance(command.attribute, dict):
+                    cmd(**command.attribute)
+                else:
+                    cmd(command.attribute)
 
     def ini_detector(self, params_state=None, controller=None):
         """ Initialize an instrument plugin class and tries to apply preset settings
@@ -1387,8 +1359,9 @@ class DAQ_Detector(QObject):
                 self.average_done = False
             self.waiting_for_data = False
 
-            # for live mode:two possibilities: either snap one data and regrab softwarewise (while True) or if
-            # self.detector.live_mode_available is True all data is continuously emitted from the plugin
+            # for live mode:two possibilities: either snap one data and regrab softwarewise
+            # (while True) or if self.detector.live_mode_available is True all data is continuously
+            # emitted from the plugin
             if self.detector.live_mode_available:
                 kwargs['wait_time'] = self.wait_time
             else:
@@ -1407,12 +1380,14 @@ class DAQ_Detector(QObject):
                             if self.average_done:
                                 break
                     else:
-                        QThread.msleep(self.wait_time)  # if in grab mode apply a waiting time after acquisition
+                        QThread.msleep(self.wait_time)  # if in grab mode apply a waiting time
+                        # after acquisition
                     if not self.grab_state:
                         break   # if not in grab mode  breaks the while loop
-                    if self.detector.live_mode_available and (not self.hardware_averaging and self.average_done):
-                        break  # if live can be done in the plugin breaks the while loop except if average is asked but
-                        # not done hardware wise
+                    if self.detector.live_mode_available and (not self.hardware_averaging and
+                                                              self.average_done):
+                        break  # if live can be done in the plugin breaks the while loop except
+                        # if average is asked but not done hardware wise
                 except Exception as e:
                     self.logger.exception(str(e))
             self.status_sig.emit(ThreadCommand('grab_stopped'))

pymodaq/control_modules/daq_viewer_ui.py

@@ -19,7 +19,8 @@ from pymodaq.utils.gui_utils.widgets import PushButtonIcon, LabelWithFont, QLED
 from pymodaq.utils.gui_utils import Dock
 from pymodaq.utils.config import Config
 from pymodaq.control_modules.utils import DET_TYPES, DAQTypesEnum
-from pymodaq.utils.plotting.data_viewers.viewer import ViewerFactory, ViewersEnum, ViewerDispatcher
+from pymodaq.utils.plotting.data_viewers.viewer import ViewerFactory, ViewerDispatcher
+from pymodaq.utils.plotting.data_viewers import ViewersEnum
 from pymodaq.utils.enums import enum_checker