pymodaq 5.0.0__py3-none-any.whl → 5.0.2__py3-none-any.whl

pymodaq/utils/data.py

@@ -1,15 +1,24 @@
 import numpy as np
 import numbers
 import warnings
+import copy
 
 from typing import List
 
 from pymodaq_utils.warnings import deprecation_msg, user_warning
 
 from pymodaq_data.data import (DataRaw, DataWithAxes, DataToExport, DataCalculated, DataDim,
-                               DataSource, DataBase, Axis, NavAxis)
+                               DataSource, DataBase, Axis, NavAxis, DataDistribution, Q_, Unit,
+                               )  # imported here for backcompatibility. Will allow also the object serialization
+                                  # registration
 
 
+from pymodaq_utils.serialize.factory import SerializableFactory, SerializableBase
+
+ser_factory = SerializableFactory()
+
+
+@ser_factory.register_decorator()
 class DataActuator(DataRaw):
     """Specialized DataWithAxes set with source as 'raw'.
     To be used for raw data generated by actuator plugins"""
@@ -24,27 +33,21 @@ class DataActuator(DataRaw):
 
     def __repr__(self):
         if self.dim.name == 'Data0D':
-            return f'<{self.__class__.__name__} ({self.data[0][0]})>'
+            return f'<{self.__class__.__name__} ({self.data[0][0]} {self.units})>'
         else:
-            return f'<{self.__class__.__name__} ({self.shape})>'
+            return f'<{self.__class__.__name__} ({self.shape} {self.units})>'
 
-    def value(self) -> float:
-        """Returns the underlying float value (of the first elt in the data list) if this data
-        holds only a float otherwise returns a mean of the underlying data"""
-        if self.length == 1 and self.size == 1:
-            return float(self.data[0][0])
-        else:
-            return float(np.mean(self.data))
+    def __add__(self, other: object):
+        if isinstance(other, numbers.Number) and self.length == 1 and self.size == 1:
+            new_data = copy.deepcopy(self)
+            new_data = new_data + DataActuator(data=other)
+            return new_data
 
-    def values(self) -> List[float]:
-        """Returns the underlying float value (for each data array in the data list) if this data
-        holds only a float otherwise returns a mean of the underlying data"""
-        if self.length == 1 and self.size == 1:
-            return [float(data_array[0]) for data_array in self.data]
         else:
-            return [float(np.mean(data_array)) for data_array in self.data]
+            return super().__add__(other)
 
 
+@ser_factory.register_decorator()
 class DataFromPlugins(DataRaw):
     """Specialized DataWithAxes set with source as 'raw'. To be used for raw data generated by Detector plugins
 
@@ -88,12 +91,14 @@ class DataFromPlugins(DataRaw):
         super().__init__(*args, **kwargs)
 
 
+@ser_factory.register_decorator()
 class DataScan(DataToExport):
     """Specialized DataToExport.To be used for data to be saved """
     def __init__(self, name: str, data: List[DataWithAxes] = [], **kwargs):
         super().__init__(name, data, **kwargs)
 
 
+@ser_factory.register_decorator()
 class DataToActuators(DataToExport):
     """ Particular case of a DataToExport adding one named parameter to indicate what kind of change
     should be applied to the actuators, absolute or relative
@@ -120,4 +125,3 @@ class DataToActuators(DataToExport):
 
     def __repr__(self):
         return f'{super().__repr__()}: {self.mode}'
-

pymodaq/utils/enums.py

@@ -0,0 +1,6 @@
+from pymodaq_utils.enums import *
+
+from pymodaq_utils.warnings import deprecation_msg
+
+deprecation_msg('Importing enums stuff from pymodaq is deprecated in pymodaq>5.0.0,'
+                'please use the pymodaq_utils.enums module')

pymodaq/utils/gui_utils/loader_utils.py

@@ -5,19 +5,42 @@ from qtpy import QtWidgets
 from pymodaq.dashboard import DashBoard
 from pymodaq.utils.gui_utils import DockArea
 from pymodaq.utils.config import get_set_preset_path
+from pymodaq.extensions.utils import CustomExt
 
 
-def load_dashboard_with_preset(preset_name: str, extension_name: str):
+def load_dashboard_with_preset(preset_name: str, extension_name: str) -> \
+        (DashBoard, CustomExt, QtWidgets.QMainWindow):
+    """ Load the Dashboard using a given preset then load an extension
+
+    Parameters
+    ----------
+    preset_name: str
+        The filename (without extension) defining the preset to be loaded in the Dashboard
+    extension_name: str
+        The name of the extension. Either the builtins ones:
+        * 'DAQScan'
+        * 'DAQLogger'
+        * 'DAQ_PID'
+        * 'Bayesian'
+
+        or the ones defined within a plugin
+
+    Returns
+    -------
+
+    """
     win = QtWidgets.QMainWindow()
     area = DockArea()
     win.setCentralWidget(area)
     win.resize(1000, 500)
-    win.setWindowTitle('PyMoDAQ Dashboard')
+    win.setWindowTitle('extension_name')
     win.show()
 
     # win.setVisible(False)
     dashboard = DashBoard(area)
 
+    preset_name = Path(preset_name).stem
+
     file = Path(get_set_preset_path()).joinpath(f"{preset_name}.xml")
 
     if file is not None and file.exists():
@@ -26,6 +49,10 @@ def load_dashboard_with_preset(preset_name: str, extension_name: str):
             extension = dashboard.load_scan_module()
         elif extension_name == 'DAQLogger':
             extension = dashboard.load_log_module()
+        elif extension_name == 'DAQ_PID':
+            extension = dashboard.load_pid_module()
+        elif extension_name == 'Bayesian':
+            extension = dashboard.load_bayesian()
         else:
             extension = dashboard.load_extension_from_name(extension_name)
     else:

pymodaq/utils/gui_utils/utils.py

@@ -1,21 +1,18 @@
-import sys
-
-from qtpy.QtCore import QObject, Signal, QEvent, QBuffer, QIODevice, Qt
-from qtpy import QtWidgets, QtCore, QtGui
-
-from pathlib import Path
 from pymodaq_utils.config import Config
 from pymodaq_utils.logger import set_logger, get_module_name
 
+from pymodaq_gui.utils.splash import get_splash_sc
+
+
 config = Config()
 logger = set_logger(get_module_name(__file__))
 
+from pymodaq_utils.warnings import deprecation_msg
+
+deprecation_msg('Importing get_splash_sc stuff from pymodaq is deprecated '
+                'in pymodaq>5.0.0,'
+                'please use the same method from the '
+                'pymodaq_gui.utils.splash module')
 
-def get_splash_sc():
-    here = Path(__file__)
-    splash_sc = QtWidgets.QSplashScreen(
-        QtGui.QPixmap(str(here.parent.parent.parent.joinpath('splash.png'))),
-        Qt.WindowStaysOnTopHint)
-    return splash_sc
 
 

pymodaq/utils/gui_utils/widgets/lcd.py

@@ -0,0 +1,8 @@
+from pymodaq_gui.utils.widgets.lcd import LCD
+
+from pymodaq_utils.warnings import deprecation_msg
+
+deprecation_msg('Importing LCD from pymodaq is deprecated '
+                'in pymodaq>5.0.0,'
+                'please use the same method from the '
+                'pymodaq_gui.utils.widgets.lcd module')

pymodaq/utils/h5modules/module_saving.py

@@ -11,7 +11,7 @@ import xml.etree.ElementTree as ET
 
 
 import numpy as np
-
+from pymodaq_utils.logger import set_logger, get_module_name
 from pymodaq_utils.abstract import ABCMeta, abstract_attribute, abstractmethod
 from pymodaq_utils.utils import capitalize
 from pymodaq_data.data import Axis, DataDim, DataWithAxes, DataToExport, DataDistribution
@@ -28,6 +28,9 @@ if TYPE_CHECKING:
     from pymodaq.extensions.daq_logger.h5logging import H5Logger
 
 
+logger = set_logger(get_module_name(__file__))
+
+
 class ModuleSaver(metaclass=ABCMeta):
     """Abstract base class to save info and data from main modules (DAQScan, DAQViewer, DAQMove, ...)"""
     group_type: GroupType = abstract_attribute()
@@ -374,7 +377,7 @@ class ScanSaver(ModuleSaver):
             try:
                 detector.insert_data(indexes, where=self._module_group, distribution=distribution)
             except Exception as e:
-                pass
+                logger.exception(f'Cannot insert data: {str(e)}')
 
 
 class LoggerSaver(ScanSaver):

pymodaq/utils/leco/daq_move_LECODirector.py

@@ -17,8 +17,7 @@ from pymodaq_gui.parameter import Parameter
 
 from pymodaq.utils.leco.leco_director import LECODirector, leco_parameters
 from pymodaq.utils.leco.director_utils import ActuatorDirector
-from pymodaq.utils.tcp_ip.serializer import DeSerializer
-
+from pymodaq_utils.serialize.serializer_legacy import DeSerializer
 
 class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
     """A control module, which in the dashboard, allows to control a remote Move module.
@@ -38,8 +37,6 @@ class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
     settings: Parameter
     controller: ActuatorDirector
 
-    is_multiaxes = False
-    axes_names = []
     params_client = []  # parameters of a client grabber
     data_actuator_type = DataActuatorType['float']  # DataActuatorType['DataActuator']
 
@@ -47,19 +44,21 @@ class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
                                                 'get_actuator_value', 'stop_motion', 'position_is',
                                                 'move_done']
     socket_types = ["ACTUATOR"]
-    params = [
-    ] + comon_parameters_fun(is_multiaxes=is_multiaxes, axes_names=axes_names) + leco_parameters
+    params = comon_parameters_fun() + leco_parameters
 
     def __init__(self, parent=None, params_state=None, **kwargs) -> None:
         super().__init__(parent=parent,
                          params_state=params_state, **kwargs)
         self.register_rpc_methods((
             self.set_info,
+        ))
+        for method in (
             self.set_position,
             self.set_move_done,
             self.set_x_axis,
             self.set_y_axis,
-        ))
+        ):
+            self.listener.register_binary_rpc_method(method, accept_binary_input=True)
 
         # copied, I think it is good:
         self.settings.child('bounds').hide()
@@ -143,22 +142,29 @@ class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
         self.controller.stop_motion()
 
     # Methods accessible via remote calls
-    def _set_position_value(self, position: Union[str, float]) -> DataActuator:
-        if isinstance(position, str):
-            deserializer = DeSerializer.from_b64_string(position)
-            pos = deserializer.dwa_deserialization()
+    def _set_position_value(
+        self, position: Union[str, float, None], additional_payload=None
+    ) -> DataActuator:
+        if position:
+            if isinstance(position, str):
+                deserializer = DeSerializer.from_b64_string(position)
+                pos = deserializer.dwa_deserialization()
+            else:
+                pos = DataActuator(data=position)
+        elif additional_payload is not None:
+            pos = DeSerializer(additional_payload[0]).dwa_deserialization()
         else:
-            pos = DataActuator(data=position)
+            raise ValueError("No position given")
         pos = self.get_position_with_scaling(pos)  # type: ignore
         self._current_value = pos
         return pos
 
-    def set_position(self, position: Union[str, float]) -> None:
-        pos = self._set_position_value(position=position)
+    def set_position(self, position: Union[str, float, None], additional_payload=None) -> None:
+        pos = self._set_position_value(position=position, additional_payload=additional_payload)
         self.emit_status(ThreadCommand('get_actuator_value', [pos]))
 
-    def set_move_done(self, position: Union[str, float]) -> None:
-        pos = self._set_position_value(position=position)
+    def set_move_done(self, position: Union[str, float, None], additional_payload=None) -> None:
+        pos = self._set_position_value(position=position, additional_payload=additional_payload)
         self.emit_status(ThreadCommand('move_done', [pos]))
 
     def set_x_axis(self, data, label: str = "", units: str = "") -> None:

pymodaq/utils/leco/daq_xDviewer_LECODirector.py

@@ -1,13 +1,14 @@
-
-from typing import Union
+from __future__ import annotations
+from typing import Optional, Union
 
 from easydict import EasyDict as edict
 
 from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base, comon_parameters, main
 
 from pymodaq_utils.utils import ThreadCommand, getLineInfo
+
 from pymodaq_gui.parameter import Parameter
-from pymodaq.utils.tcp_ip.serializer import DeSerializer
+from pymodaq_utils.serialize.serializer_legacy import DeSerializer
 
 from pymodaq.utils.leco.leco_director import LECODirector, leco_parameters
 from pymodaq.utils.leco.director_utils import DetectorDirector
@@ -29,16 +30,18 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
                                                 "Status", "Done", "Server Closed",
                                                 "Info", "Infos", "Info_xml", 'x_axis', 'y_axis']
     socket_types = ["GRABBER"]
-    params = [
-    ] + comon_parameters + leco_parameters
+    params = comon_parameters + leco_parameters
 
     def __init__(self, parent=None, params_state=None, grabber_type: str = "0D", **kwargs) -> None:
         super().__init__(parent=parent, params_state=params_state, **kwargs)
         self.register_rpc_methods((
             self.set_x_axis,
             self.set_y_axis,
-            self.set_data,
         ))
+        for method in (
+            self.set_data,
+        ):
+            self.listener.register_binary_rpc_method(method, accept_binary_input=True)
 
         self.client_type = "GRABBER"
         self.x_axis = None
@@ -150,7 +153,8 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
         self.y_axis = dict(data=data, label=label, units=units)
         self.emit_y_axis()
 
-    def set_data(self, data: Union[list, str]) -> None:
+    def set_data(self, data: Union[list, str, None],
+                 additional_payload: Optional[list[bytes]]=None) -> None:
         """
         Set the grabbed data signal.
 
@@ -160,10 +164,12 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
         """
         if isinstance(data, str):
             deserializer = DeSerializer.from_b64_string(data)
-            dte = deserializer.dte_deserialization()
-            self.dte_signal.emit(dte)
+        elif additional_payload is not None:
+            deserializer = DeSerializer(additional_payload[0])
         else:
             raise NotImplementedError("Not implemented to set a list of values.")
+        dte = deserializer.dte_deserialization()
+        self.dte_signal.emit(dte)
 
 
 if __name__ == '__main__':

pymodaq/utils/leco/leco_director.py

@@ -1,8 +1,9 @@
-
 import random
-
 from typing import Callable, Sequence, List
 
+from pymodaq_utils.enums import StrEnum
+from typing import Callable, Sequence, List, Optional, Union
+
 import pymodaq_gui.parameter.utils as putils
 # object used to send info back to the main thread:
 from pymodaq_utils.utils import ThreadCommand
@@ -14,7 +15,7 @@ from pymodaq.utils.leco.pymodaq_listener import PymodaqListener
 
 leco_parameters = [
     {'title': 'Actor name:', 'name': 'actor_name', 'type': 'str', 'value': "actor_name",
-     'text': 'Name of the actor plugin to communicate with.'},
+     'tip': 'Name of the actor plugin to communicate with.'},
 ]
 
 

pymodaq/utils/leco/pymodaq_listener.py

@@ -1,11 +1,6 @@
 
-try:
-    from enum import StrEnum  # type: ignore
-except ImportError:
-    from enum import Enum
+from pymodaq_utils.enums import StrEnum
 
-    class StrEnum(str, Enum):
-        pass
 import logging
 from threading import Event
 from typing import Optional, Union, List, Type
@@ -16,8 +11,9 @@ from qtpy.QtCore import QObject, Signal  # type: ignore
 
 from pymodaq_utils.utils import ThreadCommand
 from pymodaq_gui.parameter import ioxml
-from pymodaq.utils.tcp_ip.serializer import DataWithAxes, SERIALIZABLE, DeSerializer
-from pymodaq.utils.leco.utils import serialize_object
+from pymodaq_data.data import DataWithAxes
+from pymodaq_utils.serialize.serializer_legacy import SERIALIZABLE, DeSerializer
+from pymodaq.utils.leco.utils import binary_serialization_to_kwargs
 
 
 class LECOClientCommands(StrEnum):
@@ -220,7 +216,7 @@ class ActorListener(PymodaqListener):
             self.communicator.ask_rpc(
                 receiver=self.remote_name,
                 method="set_data",
-                data=serialize_object(value),
+                **binary_serialization_to_kwargs(value),
             )
 
         elif command.command == 'send_info':
@@ -236,14 +232,14 @@ class ActorListener(PymodaqListener):
             value = command.attribute[0]  # type: ignore
             self.communicator.ask_rpc(receiver=self.remote_name,
                                       method="set_position",
-                                      position=serialize_object(value),
+                                      **binary_serialization_to_kwargs(value, data_key="position"),
                                       )
 
         elif command.command == LECOMoveCommands.MOVE_DONE:
             value = command.attribute[0]  # type: ignore
             self.communicator.ask_rpc(receiver=self.remote_name,
                                       method="set_move_done",
-                                      position=serialize_object(value),
+                                      **binary_serialization_to_kwargs(value, data_key="position"),
                                       )
 
         elif command.command == 'x_axis':
@@ -251,7 +247,7 @@ class ActorListener(PymodaqListener):
             if isinstance(value, SERIALIZABLE):
                 self.communicator.ask_rpc(receiver=self.remote_name,
                                           method="set_x_axis",
-                                          data=serialize_object(value),
+                                          **binary_serialization_to_kwargs(value),
                                           )
             elif isinstance(value, dict):
                 self.communicator.ask_rpc(receiver=self.remote_name, method="set_x_axis", **value)
@@ -263,7 +259,7 @@ class ActorListener(PymodaqListener):
             if isinstance(value, SERIALIZABLE):
                 self.communicator.ask_rpc(receiver=self.remote_name,
                                           method="set_y_axis",
-                                          data=serialize_object(value),
+                                          **binary_serialization_to_kwargs(value),
                                           )
             elif isinstance(value, dict):
                 self.communicator.ask_rpc(receiver=self.remote_name, method="set_y_axis", **value)

pymodaq/utils/leco/utils.py

@@ -1,26 +1,59 @@
+from __future__ import annotations
 import subprocess
 import sys
-from typing import Any, Union, get_args
+from typing import Any, Optional, Union, get_args, TypeVar
 
+from pymodaq.utils import data
 # import also the DeSerializer for easier imports in dependents
-from pymodaq.utils.tcp_ip.serializer import SERIALIZABLE, Serializer, DeSerializer  # type: ignore  # noqa
+from pymodaq_utils.serialize.serializer_legacy import Serializer, DeSerializer, SerializableFactory
+
+# type: ignore  # noqa
 from pymodaq_utils.logger import set_logger
 
 
 logger = set_logger('leco_utils')
-
+ser_factory = SerializableFactory()
 JSON_TYPES = Union[str, int, float]
 
 
+
 def serialize_object(pymodaq_object: Union[SERIALIZABLE, Any]) -> Union[str, Any]:
     """Serialize a pymodaq object, if it is not JSON compatible."""
     if isinstance(pymodaq_object, get_args(JSON_TYPES)):
         return pymodaq_object
-    elif isinstance(pymodaq_object, get_args(SERIALIZABLE)):
-        return Serializer(pymodaq_object).to_b64_string()
     else:
-        raise ValueError(f"{pymodaq_object} of type '{type(pymodaq_object).__name__}' is neither "
-                         "JSON serializable, nor via PyMoDAQ.")
+        return Serializer(pymodaq_object).to_b64_string() # will raise a proper error if the object
+    #is not serializable
+
+
+## this form below is to be compatible with python <= 3.10
+## for py>= 3.11 this could be written SERIALIZABLE = Union[ser_factory.get_serializables()]
+SERIALIZABLE = Union[ser_factory.get_serializables()[0]]
+for klass in ser_factory.get_serializables()[1:]:
+    SERIALIZABLE = Union[SERIALIZABLE, klass]
+
+
+def binary_serialization(
+    pymodaq_object: Union[SERIALIZABLE, Any],
+) -> tuple[Optional[Any], Optional[list[bytes]]]:
+    """Serialize (binary) a pymodaq object, if it is not JSON compatible."""
+    if isinstance(pymodaq_object, get_args(JSON_TYPES)):
+        return pymodaq_object, None
+    elif isinstance(pymodaq_object, get_args(Union[*ser_factory.get_serializables()])):
+        return None, [Serializer(pymodaq_object).to_bytes()]
+    else:
+        raise ValueError(
+            f"{pymodaq_object} of type '{type(pymodaq_object).__name__}' is neither "
+            "JSON serializable, nor via PyMoDAQ."
+        )
+
+
+def binary_serialization_to_kwargs(
+    pymodaq_object: Union[SERIALIZABLE, Any], data_key: str = "data"
+) -> dict[str, Any]:
+    """Create a dictionary of data parameters and of additional payload to send."""
+    d, b = binary_serialization(pymodaq_object=pymodaq_object)
+    return {data_key: d, "additional_payload": b}
 
 
 def run_coordinator():

pymodaq/utils/managers/modules_manager.py

@@ -39,6 +39,7 @@ class ModulesManager(QObject, ParameterManager):
     selected_actuators: list of DAQ_Move
         sublist of actuators
     """
+    settings_name = 'ModulesManagerSettings'
     detectors_changed = Signal(list)
     actuators_changed = Signal(list)
     det_done_signal = Signal(DataToExport)  # dte here contains DataWithAxes
@@ -117,7 +118,7 @@ class ModulesManager(QObject, ParameterManager):
             modules = [modules]
         return [mod.title for mod in modules]
 
-    def get_mods_from_names(self, names, mod='det'):
+    def get_mods_from_names(self, names, mod='det') -> List[Union['DAQ_Move', 'DAQ_Viewer']]:
         """Getter of a list of given modules from their name (title)
 
         Parameters
@@ -172,9 +173,14 @@ class ModulesManager(QObject, ParameterManager):
 
     @property
     def detectors_all(self):
-        """Get the list of all detectors"""
+        """Get/Set the list of all detectors"""
         return self._detectors
 
+    @detectors_all.setter
+    def detectors_all(self, detectors: List['DAQ_Viewer']):
+        self._detectors = detectors
+
+
     @property
     def actuators(self) -> List['DAQ_Move']:
         """Get the list of selected actuators"""
@@ -185,6 +191,10 @@ class ModulesManager(QObject, ParameterManager):
         """Get the list of all actuators"""
         return self._actuators
 
+    @actuators_all.setter
+    def actuators_all(self, actuators: List['DAQ_Move']):
+        self._actuators = actuators
+
     @property
     def modules(self):
         """Get the list of all detectors and actuators"""
@@ -244,11 +254,11 @@ class ModulesManager(QObject, ParameterManager):
         elif param.name() == 'actuators':
             self.actuators_changed.emit(param.value()['selected'])
 
-    def get_det_data_list(self):
+    def get_det_data_list(self) -> DataToExport:
         """Do a snap of selected detectors, to get the list of all the data and processed data"""
 
         self.connect_detectors()
-        datas: DataToExport = self.grab_datas()
+        datas: DataToExport = self.grab_data()
 
         data_list0D = datas.get_full_names('data0D')
         data_list1D = datas.get_full_names('data1D')
@@ -265,6 +275,7 @@ class ModulesManager(QObject, ParameterManager):
             dict(all_items=data_listND, selected=[]))
 
         self.connect_detectors(False)
+        return datas
 
     def get_selected_probed_data(self, dim='0D'):
         """Get the name of selected data names of a given dimensionality
@@ -276,7 +287,7 @@ class ModulesManager(QObject, ParameterManager):
         """
         return self.settings.child('data_dimensions', f'det_data_list{dim.upper()}').value()['selected']
 
-    def grab_datas(self, **kwargs):
+    def grab_data(self, **kwargs):
         """Do a single grab of connected and selected detectors"""
         self.det_done_datas = DataToExport(name=__class__.__name__, control_module='DAQ_Viewer')
         self._received_data = 0
@@ -300,6 +311,10 @@ class ModulesManager(QObject, ParameterManager):
         self.det_done_signal.emit(self.det_done_datas)
         return self.det_done_datas
 
+    def grab_datas(self, **kwargs):
+        """ For back compatibility but use self.grab_data"""
+        return self.grab_data(**kwargs)
+
     def connect_actuators(self, connect=True, slot=None, signal='move_done'):
         """Connect the selected actuators signal to a given or default slot
 
@@ -359,12 +374,12 @@ class ModulesManager(QObject, ParameterManager):
                 sig.connect(slot)
         else:
 
-            for sig in [mod.grab_done_signal for mod in self.detectors_all]:
+            for sig in [mod.grab_done_signal for mod in self.detectors]:
                 try:
                     sig.disconnect(slot)
                 except TypeError as e:
                     # means the slot was not previously connected
-                    logger.info(str(e))
+                    logger.info(f'Could not disconnect grab signal from the {slot} slot', stacklevel=2)
 
         self.detectors_connected = connect
 
@@ -482,11 +497,6 @@ class ModulesManager(QObject, ParameterManager):
                 self.det_done_flag = True
                 self.settings.child('det_done').setValue(self.det_done_flag)
 
-        # if data.name not in list(self.det_done_datas.keys()):
-        #     self.det_done_datas[data['name']] = data
-        # if len(self.det_done_datas.items()) == len(self.detectors):
-        #     self.det_done_flag = True
-
 
 if __name__ == '__main__':
     import sys