pymodaq 4.4.7__py3-none-any.whl → 5.0.1__py3-none-any.whl

pymodaq/control_modules/daq_viewer.py

@@ -20,28 +20,37 @@ import numpy as np
 from qtpy import QtWidgets
 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_data.data import DataToExport, Axis, DataDistribution
+from pymodaq.utils.data import DataFromPlugins
+
+from pymodaq_utils.logger import set_logger, get_module_name
 from pymodaq.control_modules.utils import ParameterControlModule
-from pymodaq.utils.gui_utils.file_io import select_file
-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
-from pymodaq.utils.h5modules.saving import H5Saver
+
+from pymodaq_gui.utils.file_io import select_file
+from pymodaq_gui.utils.widgets.lcd import LCD
+
+from pymodaq_utils.config import Config, get_set_local_dir
+from pymodaq_gui.h5modules.browsing import browse_data
+from pymodaq_gui.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, Parameter
-from pymodaq.utils.parameter import utils as putils
+from pymodaq_data.h5modules.backends import Node
+from pymodaq_utils.utils import ThreadCommand
+
+from pymodaq_gui.parameter import ioxml, Parameter
+from pymodaq_gui.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 import utils
+from pymodaq_utils.warnings import deprecation_msg
+from pymodaq_gui.utils import DockArea, Dock
+from pymodaq_gui.utils.utils import mkQApp
+
+from pymodaq.utils.gui_utils import get_splash_sc
 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
-from pymodaq.utils.plotting.data_viewers import ViewersEnum
-from pymodaq.utils.enums import enum_checker
+from pymodaq_gui.plotting.data_viewers.viewer import ViewerBase
+from pymodaq_gui.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
@@ -261,6 +270,20 @@ class DAQ_Viewer(ParameterControlModule):
         deprecation_msg('viewers_docks is a deprecated property use viewer_docks instead')
         return self.viewer_docks
 
+    @property
+    def master(self) -> bool:
+        """ Get/Set programmatically the Master/Slave status of a detector"""
+        if self.initialized_state:
+            return self.settings['detector_settings', 'controller_status'] == 'Master'
+        else:
+            return True
+
+    @master.setter
+    def master(self, is_master: bool):
+        if self.initialized_state:
+            self.settings.child('detector_settings', 'controller_status').setValue(
+                'Master' if is_master else 'Slave')
+
     def daq_type_changed_from_ui(self, daq_type: DAQTypesEnum):
         """ Apply changes from the selection of a different DAQTypesEnum in the UI
 
@@ -368,7 +391,7 @@ class DAQ_Viewer(ParameterControlModule):
             return self._viewers
 
     @viewers.setter
-    def viewers(self, viewers):
+    def viewers(self, viewers: List[ViewerBase]):
         for viewer in self._viewers:
             try:
                 viewer.data_to_export_signal.disconnect()
@@ -384,6 +407,11 @@ class DAQ_Viewer(ParameterControlModule):
                 lambda roi_info: self.command_hardware.emit(
                     ThreadCommand('roi_select',
                                   dict(roi_info=roi_info, ind_viewer=ind_viewer))))
+            viewer.crosshair_dragged.connect(
+                lambda crosshair_info: self.command_hardware.emit(
+                    ThreadCommand('crosshair',
+                                  dict(crosshair_info=crosshair_info, ind_viewer=ind_viewer))))
+
 
         self._viewers = viewers
 
@@ -996,7 +1024,8 @@ class DAQ_Viewer(ParameterControlModule):
         if self.settings.child('main_settings', 'overshoot', 'stop_overshoot').value():
             for dwa in dte:
                 for data_array in dwa.data:
-                    if any(data_array >= self.settings.child('main_settings', 'overshoot', 'overshoot_value').value()):
+                    if np.any(data_array >= self.settings['main_settings', 'overshoot',
+                                                          'overshoot_value']):
                         self.overshoot_signal.emit(True)
 
     def get_scaling_options(self):
@@ -1038,11 +1067,11 @@ class DAQ_Viewer(ParameterControlModule):
         super().thread_status(status, 'detector')
 
         if status.command == "ini_detector":
-            self.update_status("detector initialized: " + str(status.attribute[0]['initialized']))
+            self.update_status("detector initialized: " + str(status.attribute['initialized']))
             if self.ui is not None:
-                self.ui.detector_init = status.attribute[0]['initialized']
-            if status.attribute[0]['initialized']:
-                self.controller = status.attribute[0]['controller']
+                self.ui.detector_init = status.attribute['initialized']
+            if status.attribute['initialized']:
+                self.controller = status.attribute['controller']
                 self._initialized_state = True
             else:
                 self._initialized_state = False
@@ -1206,7 +1235,7 @@ class DAQ_Detector(QObject):
         """
         if command.command == "ini_detector":
             status = self.ini_detector(*command.attribute)
-            self.status_sig.emit(ThreadCommand(command.command, [status, 'log']))
+            self.status_sig.emit(ThreadCommand(command.command, status))
 
         elif command.command == "close":
             status = self.close()
@@ -1408,7 +1437,7 @@ class DAQ_Detector(QObject):
     def close(self):
         """ Call the close method of the instrument plugin class
         """
-        if self.detector is not None:
+        if self.detector is not None and self.detector.controller is not None:
             status = self.detector.close()
             return status
 
@@ -1436,16 +1465,12 @@ def main(init_qt=True, init_det=False):
     """ Method called to start the DAQ_Viewer in standalone mode"""
 
     if init_qt:  # used for the test suite
-        app = QtWidgets.QApplication(sys.argv)
-        if config('style', 'darkstyle'):
-            import qdarkstyle
-            app.setStyleSheet(qdarkstyle.load_stylesheet(qdarkstyle.DarkPalette))
+        app = mkQApp("PyMoDAQ Viewer")
 
     win = QtWidgets.QMainWindow()
     area = DockArea()
     win.setCentralWidget(area)
     win.resize(1000, 500)
-    win.setWindowTitle('PyMoDAQ Viewer')
     win.show()
 
     title = "Testing"

pymodaq/control_modules/daq_viewer_ui.py

@@ -15,13 +15,13 @@ from qtpy.QtWidgets import QVBoxLayout,  QWidget, QComboBox
 from pymodaq.utils.daq_utils import ThreadCommand
 from pymodaq.control_modules.utils import ControlModuleUI
 
-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_gui.utils.widgets import PushButtonIcon, LabelWithFont, QLED
+from pymodaq_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, ViewerDispatcher
-from pymodaq.utils.plotting.data_viewers import ViewersEnum
-from pymodaq.utils.enums import enum_checker
+from pymodaq_gui.plotting.data_viewers.viewer import ViewerFactory, ViewerDispatcher
+from pymodaq_gui.plotting.data_viewers import ViewersEnum
+from pymodaq_utils.enums import enum_checker
 
 
 viewer_factory = ViewerFactory()

pymodaq/control_modules/mocks.py

@@ -5,7 +5,7 @@ Created the 16/03/2023
 @author: Sebastien Weber
 """
 from pymodaq.utils.parameter import Parameter
-from pymodaq.utils.h5modules import saving
+from pymodaq_gui.h5modules import saving
 from pymodaq.utils.h5modules.module_saving import DetectorSaver, ActuatorSaver, ScanSaver
 
 

pymodaq/control_modules/move_utility_classes.py

@@ -10,20 +10,27 @@ import numpy as np
 from qtpy import QtWidgets
 from qtpy.QtCore import QObject, Slot, Signal, QTimer
 
-import pymodaq.utils.daq_utils as utils
-import pymodaq.utils.parameter.utils as putils
-from pymodaq.utils.parameter import Parameter
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils.parameter import ioxml
-
-from pymodaq.utils.daq_utils import ThreadCommand, getLineInfo, find_keys_from_val
-from pymodaq.utils import config as configmod
+from pymodaq_utils.utils import ThreadCommand, find_keys_from_val
+from pymodaq_utils import config as configmod
+from pymodaq_utils.warnings import deprecation_msg
+from pymodaq_utils.enums import BaseEnum, enum_checker
+from pymodaq_utils.logger import set_logger, get_module_name
+
+import pymodaq_gui.parameter.utils as putils
+from pymodaq_gui.parameter import Parameter
+from pymodaq_gui.parameter import ioxml
+from pymodaq_gui.utils.utils import mkQApp
+
 from pymodaq.utils.tcp_ip.tcp_server_client import TCPServer, tcp_parameters
+
+from pymodaq_data.data import DataUnitError, Q_
+
 from pymodaq.utils.messenger import deprecation_msg
-from pymodaq.utils.data import DataActuator, DataUnitError
-from pymodaq.utils.enums import BaseEnum, enum_checker
-from pymodaq.utils.tcp_ip.mysocket import Socket
-from pymodaq.utils.tcp_ip.serializer import DeSerializer, Serializer
+from pymodaq.utils.data import DataActuator
+from pymodaq_utils.enums import BaseEnum, enum_checker
+
+from pymodaq_utils.serialize.mysocket import Socket
+from pymodaq_utils.serialize.serializer_legacy import DeSerializer, Serializer
 from pymodaq import Unit
 from pint.errors import OffsetUnitCalculusError
 
@@ -67,11 +74,11 @@ class DataActuatorType(BaseEnum):
 def comon_parameters(epsilon=config('actuator', 'epsilon_default'),
                      epsilons=None):
     if epsilons is not None:
-        epsilon=epsilons
+        epsilon = epsilons
     if isinstance(epsilon, list):
-        epsilon=epsilon[0]
+        epsilon = epsilon[0]
     elif isinstance(epsilon, dict):
-        epsilon=epsilon[list[epsilon.keys()][0]]
+        epsilon = epsilon[list[epsilon.keys()][0]]
 
     return [{'title': 'Units:', 'name': 'units', 'type': 'str', 'value': '', 'readonly': True},
             {'title': 'Epsilon:', 'name': 'epsilon', 'type': 'float',
@@ -124,7 +131,7 @@ def comon_parameters_fun(is_multiaxes=False, axes_names=None,
 
     Parameters
     ----------
-    is_multiaxes: bool  # deprecated not need anymore
+    is_multiaxes: bool
         If True, display the particular settings to define which axis the controller is driving
     axes_names: deprecated, use axis_names
     axis_names: list of str or dictionnary of string as key and integer as value
@@ -140,7 +147,7 @@ def comon_parameters_fun(is_multiaxes=False, axes_names=None,
             axes_names = ['']
         axis_names = axes_names
 
-    is_multiaxes = len(axis_names) > 1
+    is_multiaxes = len(axis_names) > 1 or is_multiaxes
     if isinstance(axis_names, list):
         if len(axis_names) > 0:
             axis_name = axis_names[0]
@@ -149,11 +156,14 @@ def comon_parameters_fun(is_multiaxes=False, axes_names=None,
             axis_name = ''
     elif isinstance(axis_names, dict):
         axis_name = axis_names[list(axis_names.keys())[0]]
+    else:
+        raise ValueError('axis_names should be either a list of string or a dict with strings '
+                         'as keys')
     params = [
                  {'title': 'MultiAxes:', 'name': 'multiaxes', 'type': 'group',
-                  'visible': is_multiaxes, 'children': [
-                     {'title': 'is Multiaxes:', 'name': 'ismultiaxes', 'type': 'bool',
-                      'value': is_multiaxes,  'default': False},
+                  'visible': True, 'children': [
+                     {'title': 'Controller ID:', 'name': 'controller_ID', 'type': 'int', 'value': 0,
+                      '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,
@@ -168,7 +178,7 @@ params = [
         {'title': 'Actuator type:', 'name': 'move_type', 'type': 'str', 'value': '', 'readonly': True},
         {'title': 'Actuator name:', 'name': 'module_name', 'type': 'str', 'value': '', 'readonly': True},
         {'title': 'Plugin Config:', 'name': 'plugin_config', 'type': 'bool_push', 'label': 'Show Config', },
-        {'title': 'Controller ID:', 'name': 'controller_ID', 'type': 'int', 'value': 0, 'default': 0},
+
         {'title': 'Refresh value (ms):', 'name': 'refresh_timeout', 'type': 'int',
             'value': config('actuator', 'refresh_timeout_ms')},
         {'title': 'TCP/IP options:', 'name': 'tcpip', 'type': 'group', 'visible': True, 'expanded': False,
@@ -205,13 +215,13 @@ def main(plugin_file, init=True, title='test'):
     from qtpy import QtWidgets
     from pymodaq.control_modules.daq_move import DAQ_Move
     from pathlib import Path
-    app = QtWidgets.QApplication(sys.argv)
-    if config('style', 'darkstyle'):
-        import qdarkstyle
-        app.setStyleSheet(qdarkstyle.load_stylesheet())
+
+    act = Path(plugin_file).stem.split('daq_move_')[1]
+
+    app = mkQApp("PyMoDAQ Viewer")
 
     widget = QtWidgets.QWidget()
-    prog = DAQ_Move(widget, title=title,)
+    prog = DAQ_Move(widget, title=title, actuator=act)
     widget.show()
     prog.actuator = Path(plugin_file).stem[9:]
     if init:
@@ -507,9 +517,10 @@ class DAQ_Move_base(QObject):
             old_controller = slave_controller
 
         self.status.update(edict(info="", controller=None, initialized=False))
-        if self.settings['multiaxes', 'ismultiaxes'] and not self.is_master:
+        if not self.is_master:
             if old_controller is None:
-                raise Exception('no controller has been defined externally while this axe is a slave one')
+                raise Exception('no controller has been defined externally while this axe '
+                                'is a slave one')
             else:
                 controller = old_controller
         else:  # Master stage
@@ -581,7 +592,6 @@ class DAQ_Move_base(QObject):
         """
         return self.settings['multiaxes', 'multi_status'] == 'Master'
 
-
     @property
     def ispolling(self):
         """ Get/Set the polling status"""
@@ -596,18 +606,11 @@ class DAQ_Move_base(QObject):
 
         Return the new position eventually coerced within the bounds
         """
-        if self.settings.child('bounds', 'is_bounds').value():
-            if position > self.settings.child('bounds', 'max_bound').value():
-                position = DataActuator(self._title,
-                                        data=self.settings.child('bounds', 'max_bound').value(),
-                                        units=self.axis_unit)
-                self.emit_status(ThreadCommand('outofbounds', []))
-            elif position < self.settings.child('bounds', 'min_bound').value():
-                position = DataActuator(self._title,
-                                        data=self.settings.child('bounds', 'min_bound').value(),
-                                        units=self.axis_unit
-                                        )
-                self.emit_status(ThreadCommand('outofbounds', []))
+        if self.settings['bounds', 'is_bounds']:
+            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', []))
         return position
 
     def get_actuator_value(self):
@@ -617,6 +620,10 @@ class DAQ_Move_base(QObject):
         else:
             raise NotImplementedError
 
+
+    def close(self):
+        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)
@@ -773,6 +780,7 @@ class DAQ_Move_base(QObject):
                 logger.info('Timeout activated')
         else:
             self.poll_timer.stop()
+            self.current_value = self.get_actuator_value()
             logger.debug(f'Current value: {self._current_value}')
             self.move_done(self._current_value)
 
@@ -907,13 +915,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('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('move_done', pos))
             else:
                 self.send_command(sock, command)
 

pymodaq/control_modules/utils.py

@@ -11,18 +11,22 @@ from easydict import EasyDict as edict
 
 from qtpy import QtCore
 from qtpy.QtCore import Signal, QObject, Qt, Slot, QThread
-from pymodaq.utils.gui_utils import CustomApp
-from pymodaq.utils.daq_utils import ThreadCommand, get_plugins, find_dict_in_list_from_key_val
-from pymodaq.utils.config import Config
+
+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.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.managers.parameter_manager import ParameterManager
+from pymodaq_gui.plotting.data_viewers import ViewersEnum
+
 from pymodaq.utils.tcp_ip.tcp_server_client import TCPClient
-from pymodaq.utils.parameter import Parameter, ioxml
-from pymodaq.utils.managers.parameter_manager import ParameterManager
-from pymodaq.utils.enums import BaseEnum, enum_checker
-from pymodaq.utils.plotting.data_viewers import ViewersEnum
 from pymodaq.utils.exceptions import DetectorError
-from pymodaq.utils import config as configmod
 from pymodaq.utils.leco.pymodaq_listener import ActorListener, LECOClientCommands, LECOCommands
-from pymodaq.utils.logger import get_base_logger
+
+from pymodaq.utils.daq_utils import get_plugins
 
 
 class DAQTypesEnum(BaseEnum):
@@ -60,17 +64,21 @@ class DAQTypesEnum(BaseEnum):
     def get_dim(self):
         return self.value.split('Viewer')[1].split('D')[0]
 
+
 DAQ_TYPES = DAQTypesEnum
 
 DET_TYPES = {'DAQ0D': get_plugins('daq_0Dviewer'),
              'DAQ1D': get_plugins('daq_1Dviewer'),
              'DAQ2D': get_plugins('daq_2Dviewer'),
-             'DAQND': get_plugins('daq_NDviewer'),}
+             'DAQND': get_plugins('daq_NDviewer'),
+             }
 
 if len(DET_TYPES['DAQ0D']) == 0:
     raise DetectorError('No installed Detector')
 
+
 config = Config()
+logger = set_logger(get_module_name(__file__))
 
 
 class ViewerError(Exception):
@@ -123,11 +131,14 @@ class ControlModule(QObject):
         self._tcpclient_thread = None
         self._hardware_thread = None
         self.module_and_data_saver = None
-        self.plugin_config: Optional[configmod.Config] = None
+        self.plugin_config: Optional[Config] = None
 
     def __repr__(self):
         return f'{self.__class__.__name__}: {self.title}'
 
+    def custom_command(self, command: str, **kwargs):
+        self.command_hardware.emit(ThreadCommand(command, kwargs))
+
     def thread_status(self, status: ThreadCommand, control_module_type='detector'):
         """Get back info (using the ThreadCommand object) from the hardware
 
@@ -138,7 +149,8 @@ class ControlModule(QObject):
         ----------
         status: ThreadCommand
             The info returned from the hardware, the command (str) can be either:
-                * Update_Status: display messages and log info
+                * Update_Status: display messages and log info (deprecated)
+                * update_status: display info on the UI status bar
                 * close: close the current thread and delete corresponding attribute on cascade.
                 * update_settings: Update the "detector setting" node in the settings tree.
                 * update_main_settings: update the "main setting" node in the settings tree
@@ -154,6 +166,9 @@ class ControlModule(QObject):
             else:
                 self.update_status(status.attribute[0])
 
+        elif status.command == 'update_status':
+            self.update_status(status.attribute)
+
         elif status.command == "close":
             try:
                 self.update_status(status.attribute[0])
@@ -167,7 +182,7 @@ class ControlModule(QObject):
                     self._hardware_thread.terminate()
                     self.update_status('thread is locked?!', 'log')
             except Exception as e:
-                self.logger.exception(str(e))
+                logger.exception(f'Wrong call to the "close" command: \n{str(e)}')
 
             self._initialized_state = False
             self.init_signal.emit(self._initialized_state)
@@ -182,7 +197,7 @@ class ControlModule(QObject):
                 elif status.attribute[2] == 'options':
                     self.settings.child('main_settings', *status.attribute[0]).setOpts(**status.attribute[1])
             except Exception as e:
-                self.logger.exception(str(e))
+                logger.exception(f'Wrong call to the "update_main_settings" command: \n{str(e)}')
 
         elif status.command == 'update_settings':
             # using this the settings shown in the UI for the plugin reflects the real plugin settings
@@ -190,7 +205,7 @@ class ControlModule(QObject):
                 self.settings.sigTreeStateChanged.disconnect(
                     self.parameter_tree_changed)  # any changes on the detcetor settings will update accordingly the gui
             except Exception as e:
-                self.logger.exception(str(e))
+                logger.exception(str(e))
             try:
                 if status.attribute[2] == 'value':
                     self.settings.child(f'{control_module_type}_settings',
@@ -209,9 +224,18 @@ class ControlModule(QObject):
                                         *status.attribute[0]).addChild(status.attribute[1][0])
 
             except Exception as e:
-                self.logger.exception(str(e))
+                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':
+            try:
+                if self.ui is not None:
+                    if hasattr(self.ui, status.attribute):
+                        getattr(self.ui, status.attribute)(*status.args,
+                                                           **status.kwargs)
+            except Exception as e:
+                logger.info(f'Wrong call to the "update_ui" command: \n{str(e)}')
+
         elif status.command == 'raise_timeout':
             self.raise_timeout()
 
@@ -295,12 +319,12 @@ class ControlModule(QObject):
     def show_log(self):
         """Open the log file in the default text editor"""
         import webbrowser
-        webbrowser.open(get_base_logger(self.logger).handlers[0].baseFilename)
+        webbrowser.open(get_base_logger(logger).handlers[0].baseFilename)
 
     def show_config(self, config: Config) -> Config:
         """ Display in a tree the current configuration"""
         if config is not None:
-            from pymodaq.utils.gui_utils.widgets.tree_toml import TreeFromToml
+            from pymodaq_gui.utils.widgets.tree_toml import TreeFromToml
             config_tree = TreeFromToml(config)
             config_tree.show_dialog()
 
@@ -320,7 +344,7 @@ class ControlModule(QObject):
             self.ui.display_status(txt)
         self.status_sig.emit(txt)
         if log:
-            self.logger.info(txt)
+            logger.info(txt)
 
     def manage_ui_actions(self, action_name: str, attribute: str, value):
         """Method to manage actions for the UI (if any).
@@ -358,7 +382,6 @@ class ParameterControlModule(ParameterManager, ControlModule):
     listener_class: Type[ActorListener] = ActorListener
 
     def __init__(self, **kwargs):
-        QObject.__init__(self)
         ParameterManager.__init__(self, action_list=('save', 'update'))
         ControlModule.__init__(self)