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

pymodaq/examples/function_plotter.py

@@ -11,17 +11,13 @@ from qtpy.QtCore import Slot, QDate, QThread, QTimer
 
 from pymodaq.utils import data as data_mod
 from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils.gui_utils.custom_app import CustomApp
-from pymodaq.utils.gui_utils.dock import DockArea, Dock
-from pymodaq.utils.gui_utils.file_io import select_file
-from pymodaq.utils.config import Config
+from pymodaq_gui.utils.custom_app import CustomApp
+from pymodaq_gui.utils.dock import DockArea, Dock
+from pymodaq_data.data import DataRaw, Axis
+from pymodaq_utils.config import Config
 
-from pymodaq.utils import gui_utils as gutils
-from pymodaq.utils import daq_utils as utils
+from pymodaq_gui.plotting.data_viewers.viewer1D import Viewer1D
 
-from pymodaq.utils.parameter import ioxml
-from pymodaq.utils.plotting.data_viewers.viewer1D import Viewer1D
-from pymodaq.utils.h5modules import H5Browser, H5Saver
 
 config = Config()
 logger = set_logger(get_module_name(__file__))
@@ -113,8 +109,14 @@ class FunctionPlotter(CustomApp):
 
         function_vals = eval(f'np.{function_str}')
 
-        self.viewer.show_data([function_vals], labels=[function_str], x_axis=data_mod.Axis(x, label='An axis',
-                                                                                             units='arb. units'))
+        self.viewer.show_data(DataRaw(name=function_str,
+                                      data=[function_vals],
+                                      labels=[function_str],
+                                      axes=[
+                                          data_mod.Axis(
+                                              data=x, label='An axis', units='arb. units')],
+                                      )
+                              )
 
     def value_changed(self, param):
         if param.name() == 'add_function':
@@ -141,7 +143,6 @@ class FunctionPlotter(CustomApp):
             self.timer.stop()
 
 
-
 def main():
     import sys
     app = QtWidgets.QApplication(sys.argv)

pymodaq/examples/tcp_client.py

@@ -15,7 +15,7 @@ You should see the TCP server printing the sinus in its 0D data viewer
 import numpy as np
 
 from pymodaq.utils.tcp_ip.tcp_server_client import TCPClientTemplate
-from pymodaq.utils.data import DataToExport, DataRaw
+from pymodaq_data.data import DataToExport, DataRaw
 
 
 class TCPClient(TCPClientTemplate):

pymodaq/extensions/__init__.py

@@ -9,7 +9,7 @@ from .pid.utils import get_models
 
 from .console import QtConsole
 from .daq_scan import DAQScan
-from .daq_logger import DAQ_Logger
+from .daq_logger.daq_logger import DAQ_Logger
 from .pid.pid_controller import DAQ_PID
 from .h5browser import H5Browser
 

pymodaq/extensions/bayesian/bayesian_optimisation.py

@@ -6,33 +6,49 @@ from qtpy import QtWidgets, QtCore
 import time
 import numpy as np
 
-
 from pymodaq.utils.data import DataToExport, DataToActuators, DataCalculated, DataActuator
-from pymodaq.utils.plotting.data_viewers.viewer0D import Viewer0D
-from pymodaq.utils.plotting.data_viewers.viewer import ViewerDispatcher, ViewersEnum
+from pymodaq.utils.managers.modules_manager import ModulesManager
+from pymodaq_utils import utils
+from pymodaq_utils import config as config_mod
+from pymodaq_utils.enums import BaseEnum
+
+from pymodaq_gui.config import ConfigSaverLoader
+from pymodaq_utils.logger import set_logger, get_module_name
+
+from pymodaq_gui.plotting.data_viewers.viewer0D import Viewer0D
+from pymodaq_gui.plotting.data_viewers.viewer import ViewerDispatcher, ViewersEnum
+from pymodaq_gui.utils import QLED
+from pymodaq_gui.utils.utils import mkQApp
+from pymodaq_gui import utils as gutils
+from pymodaq_gui.parameter import utils as putils
+from pymodaq_gui.h5modules.saving import H5Saver
+
+from pymodaq_data.h5modules.data_saving import DataEnlargeableSaver
+
+
 from pymodaq.extensions.bayesian.utils import (get_bayesian_models, BayesianModelGeneric,
                                                BayesianAlgorithm, UtilityKind,
                                                UtilityParameters, StopType, StoppingParameters)
-from pymodaq.utils.gui_utils import QLED
-from pymodaq.utils.managers.modules_manager import ModulesManager
-from pymodaq.utils import gui_utils as gutils
-from pymodaq.utils import daq_utils as utils
-from pymodaq.utils.parameter import utils as putils
-from pymodaq.utils.h5modules.saving import H5Saver
-from pymodaq.utils.h5modules.data_saving import DataEnlargeableSaver
 from pymodaq.post_treatment.load_and_plot import LoaderPlotter
 from pymodaq.extensions.bayesian.utils import BayesianConfig
-from pymodaq.utils import config as configmod
-from pymodaq.utils.logger import set_logger, get_module_name
-
+from pymodaq.extensions.utils import CustomExt
 
 EXTENSION_NAME = 'BayesianOptimisation'
 CLASS_NAME = 'BayesianOptimisation'
 
 logger = set_logger(get_module_name(__file__))
+config = config_mod.Config()
 
 
-class BayesianOptimisation(gutils.CustomApp):
+class DataNames(BaseEnum):
+    Fitness = 0
+    Individual = 1
+    ProbedData = 2
+    Actuators = 3
+    Kappa = 4
+
+
+class BayesianOptimisation(CustomExt):
     """ PyMoDAQ extension of the DashBoard to perform the optimization of a target signal
     taken form the detectors as a function of one or more parameters controlled by the actuators.
     """
@@ -109,7 +125,7 @@ class BayesianOptimisation(gutils.CustomApp):
         self.setup_ui()
 
         self.bayesian_config = BayesianConfig()
-        self.mainsettings_saver_loader = configmod.ConfigSaverLoader(
+        self.mainsettings_saver_loader = ConfigSaverLoader(
             self.settings.child('main_settings'), self.bayesian_config)
 
         self.h5temp: H5Saver = None
@@ -173,7 +189,7 @@ class BayesianOptimisation(gutils.CustomApp):
             params = getattr(model_class, 'params')
             self.settings.child('models', 'model_params').addChildren(params)
 
-    def setup_menu(self):
+    def setup_menu(self, menubar: QtWidgets.QMenuBar = None):
         '''
         to be subclassed
         create menu for actions contained into the self.actions_manager, for instance:
@@ -447,20 +463,20 @@ class BayesianOptimisation(gutils.CustomApp):
     def process_output(self, dte: DataToExport):
 
         self.enl_index += 1
-        dwa_kappa = dte.remove(dte.get_data_from_name('kappa'))
+        dwa_kappa = dte.remove(dte.get_data_from_name(DataNames.Kappa.name))
         self.settings.child('main_settings', 'utility', 'kappa_actual').setValue(
             float(dwa_kappa[0][0])
         )
 
-        dwa_data = dte.remove(dte.get_data_from_name('ProbedData'))
-        dwa_actuators: DataActuator = dte.remove(dte.get_data_from_name('Actuators'))
+        dwa_data = dte.remove(dte.get_data_from_name(DataNames.ProbedData.name))
+        dwa_actuators: DataActuator = dte.remove(dte.get_data_from_name(DataNames.Actuators.name))
         self.viewer_observable.show_data(dte)
 
         # dwa_observations = self.algorithm.get_dwa_obervations(
         #     self.modules_manager.selected_actuators_name)
         self.model_class.update_plots()
 
-        best_individual = dte.get_data_from_name('Individual')
+        best_individual = dte.get_data_from_name(DataNames.Individual.name)
         best_indiv_as_list = [float(best_individual[ind][0]) for ind in range(len(best_individual))]
 
 
@@ -579,7 +595,7 @@ class OptimisationRunner(QtCore.QObject):
                                                     polling=sync_acts)
 
                 # Do the evaluation (measurements)
-                self.det_done_datas = self.modules_manager.grab_datas()
+                self.det_done_datas = self.modules_manager.grab_data()
                 self.input_from_dets = self.model_class.convert_input(self.det_done_datas)
 
                 # Run the algo internal mechanic
@@ -588,17 +604,17 @@ class OptimisationRunner(QtCore.QObject):
                 dte = DataToExport('algo',
                                    data=[self.individual_as_data(
                                        np.array([self.optimisation_algorithm.best_fitness]),
-                                       'Fitness'),
+                                       DataNames.Fitness.name),
                                        self.individual_as_data(
                                            self.optimisation_algorithm.best_individual,
-                                           'Individual'),
-                                       DataCalculated('ProbedData',
+                                           DataNames.Individual.name),
+                                       DataCalculated(DataNames.ProbedData.name,
                                                       data=[np.array([self.input_from_dets])],
                                                       ),
-                                       self.output_to_actuators.merge_as_dwa('Data0D',
-                                                                             'Actuators'),
+                                       self.output_to_actuators.merge_as_dwa(
+                                           'Data0D', DataNames.Actuators.name),
                                        DataCalculated(
-                                           'kappa',
+                                           DataNames.Kappa.name,
                                            data=[
                                                np.array([self.optimisation_algorithm.kappa])])
                                          ])
@@ -635,10 +651,7 @@ def main(init_qt=True):
     from pymodaq.utils.daq_utils import get_set_preset_path
 
     if init_qt:  # used for the test suite
-        app = QtWidgets.QApplication(sys.argv)
-
-        import qdarkstyle
-        app.setStyleSheet(qdarkstyle.load_stylesheet())
+        app = mkQApp("PyMoDAQ Dashboard")
 
     from pymodaq.dashboard import DashBoard
 
@@ -646,7 +659,6 @@ def main(init_qt=True):
     area = gutils.dock.DockArea()
     win.setCentralWidget(area)
     win.resize(1000, 500)
-    win.setWindowTitle('PyMoDAQ Dashboard')
 
     dashboard = DashBoard(area)
     daq_scan = None

pymodaq/extensions/bayesian/utils.py

@@ -11,24 +11,24 @@ import importlib
 import pkgutil
 import inspect
 import numpy as np
-from qtpy import QtWidgets
-import tempfile
 from collections import namedtuple
 
 from bayes_opt import BayesianOptimization
 from bayes_opt import UtilityFunction
 
+from pymodaq_utils.utils import find_dict_in_list_from_key_val, get_entrypoints
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.enums import BaseEnum
+from pymodaq_utils.config import BaseConfig
 
-from pymodaq.utils.h5modules.saving import H5Saver
-from pymodaq.utils.data import (DataToExport, DataActuator, DataToActuators, DataCalculated,
+from pymodaq_gui.parameter import Parameter
+from pymodaq_gui.plotting.data_viewers.viewer import ViewersEnum
+
+from pymodaq_data.data import (DataToExport, DataCalculated,
                                 DataRaw, Axis)
+
+from pymodaq.utils.data import DataActuator, DataToActuators
 from pymodaq.utils.managers.modules_manager import ModulesManager
-from pymodaq.utils.daq_utils import find_dict_in_list_from_key_val, get_entrypoints
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils.plotting.data_viewers.viewer import ViewersEnum
-from pymodaq.utils.enums import BaseEnum
-from pymodaq.utils.parameter import Parameter
-from pymodaq.utils.config import BaseConfig
 
 
 if TYPE_CHECKING:

pymodaq/extensions/console.py

@@ -4,15 +4,17 @@ Created the 25/10/2022
 
 @author: Sebastien Weber
 """
-from qtpy import QtWidgets
+
 from qtconsole.rich_jupyter_widget import RichJupyterWidget
 from qtconsole.inprocess import QtInProcessKernelManager
-from pymodaq.utils import config as configmod
-from pymodaq.utils.daq_utils import get_version
+
+from pymodaq_utils import config as configmod
+from pymodaq_utils.utils import get_version
 
 
 config = configmod.Config()
-BANNER = f'PyMoDAQ v{get_version()}\n' \
+
+BANNER = f'PyMoDAQ v{get_version("pymodaq")}\n' \
          'Main objects available for interaction:\n'\
          '* dashboard: Main Dashboard Object\n'\
          '* mods: ModuleManager of the dashboard\'s Control Modules\n'\
@@ -54,8 +56,7 @@ class QtConsole(RichJupyterWidget):
 
 
 def main():
-    from pymodaq.utils.gui_utils.utils import mkQApp
-
+    from pymodaq_gui.utils.utils import mkQApp
 
     app = mkQApp('Console')
 

pymodaq/extensions/daq_logger/__init__.py

@@ -0,0 +1 @@
+from .daq_logger import main

pymodaq/extensions/{daq_logger.py → daq_logger/daq_logger.py}

@@ -11,47 +11,46 @@ from collections import OrderedDict
 import datetime
 from typing import TYPE_CHECKING, Union
 
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils.gui_utils.custom_app import CustomApp
-from pymodaq.utils.gui_utils.dock import Dock
-from pymodaq.utils.config import Config, get_set_preset_path
-import pymodaq.utils.parameter.ioxml
-import numpy as np
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_gui.utils.dock import Dock, DockArea
+from pymodaq_utils.config import Config
+from pymodaq_gui.parameter import ioxml
+
 from qtpy import QtWidgets
 from qtpy.QtCore import QObject, Slot, QThread, Signal, Qt
-from pymodaq.utils import data as data_mod
-from pymodaq.utils.gui_utils.widgets import QLED
-from pymodaq.utils.gui_utils.dock import DockArea
-from pymodaq.utils import daq_utils as utils
-from pymodaq.utils.h5modules.h5logging import H5Logger
-from pymodaq.utils.managers.modules_manager import ModulesManager
-from pymodaq.utils.data import DataToExport, DataActuator, DataWithAxes
 
+from pymodaq_gui.utils.widgets import QLED
+
+
+from pymodaq.extensions.daq_logger.h5logging import H5Logger
+from pymodaq.utils.managers.modules_manager import ModulesManager
+from pymodaq.utils.data import DataActuator, DataToExport
+from pymodaq.extensions.utils import CustomExt
 
 if TYPE_CHECKING:
     from pymodaq.dashboard import DashBoard
 
 
-
 config = Config()
 logger = set_logger(get_module_name(__file__))
 
 
 try:
     import sqlalchemy
-    from pymodaq.utils.db.db_logger.db_logger import DataBaseLogger
+    from pymodaq.extensions.daq_logger.db.db_logger import DataBaseLogger
     is_sql = True
 except Exception as e:
     is_sql = False
-    logger.info('To enable logging to database install: sqalchemy and sqlalchemy_utils packages as well as the '
-                'backend for your specific database, for instance psycopg2 for PostGreSQL database')
+    logger.info('To enable logging to database install: sqalchemy and sqlalchemy_utils packages as'
+                ' well as the backend for your specific database, for instance psycopg2 for'
+                ' PostGreSQL database')
 
 LOG_TYPES = ['None', 'H5 File']
 if is_sql:
     LOG_TYPES.append('SQL DataBase')
 
 
-class DAQ_Logger(CustomApp):
+class DAQ_Logger(CustomExt):
     """
     Main class initializing a DAQ_Logger module
     """
@@ -147,10 +146,10 @@ class DAQ_Logger(CustomApp):
 
         self._actions['infos'].connect_to(self.dashboard.show_log)
 
-    def setup_menu(self):
+    def setup_menu(self, menubar: QtWidgets.QMenuBar = None):
         """
         """
-        file_menu = self.mainwindow.menuBar().addMenu('File')
+        file_menu = menubar.addMenu('File')
         self.affect_to('infos', file_menu)
 
     def value_changed(self, param):
@@ -204,17 +203,17 @@ class DAQ_Logger(CustomApp):
             self.logger.settings.child('N_saved').setValue(0)
 
             settings_str = b'<All_settings>'
-            settings_str += pymodaq.utils.parameter.ioxml.parameter_to_xml_string(self.dashboard.settings)
-            settings_str += pymodaq.utils.parameter.ioxml.parameter_to_xml_string(
+            settings_str += ioxml.parameter_to_xml_string(self.dashboard.settings)
+            settings_str += ioxml.parameter_to_xml_string(
                 self.dashboard.preset_manager.preset_params)
             if self.dashboard.settings.child('loaded_files', 'overshoot_file').value() != '':
-                settings_str += pymodaq.utils.parameter.ioxml.parameter_to_xml_string(
+                settings_str += ioxml.parameter_to_xml_string(
                     self.dashboard.overshoot_manager.overshoot_params)
             if self.dashboard.settings.child('loaded_files', 'roi_file').value() != '':
-                settings_str += pymodaq.utils.parameter.ioxml.parameter_to_xml_string(
+                settings_str += ioxml.parameter_to_xml_string(
                     self.dashboard.roi_saver.roi_presets)
-            settings_str += pymodaq.utils.parameter.ioxml.parameter_to_xml_string(self.settings)
-            settings_str += pymodaq.utils.parameter.ioxml.parameter_to_xml_string(self.logger.settings)
+            settings_str += ioxml.parameter_to_xml_string(self.settings)
+            settings_str += ioxml.parameter_to_xml_string(self.logger.settings)
             settings_str += b'</All_settings>'
 
             if not self.logger.init_logger(settings_str):
@@ -241,12 +240,12 @@ class DAQ_Logger(CustomApp):
                 # create the detectors in the chosen logger
                 for mod in modules_log:
                     settings_str = b'<All_settings>'
-                    settings_str += pymodaq.utils.parameter.ioxml.parameter_to_xml_string(mod.settings)
+                    settings_str += ioxml.parameter_to_xml_string(mod.settings)
 
                     if mod.module_type == 'DAQ_Viewer':
                         for viewer in mod.ui.viewers:
                             if hasattr(viewer, 'roi_manager'):
-                                settings_str += pymodaq.utils.parameter.ioxml.parameter_to_xml_string(
+                                settings_str += ioxml.parameter_to_xml_string(
                                     viewer.roi_manager.settings)
                     settings_str += b'</All_settings>'
                     if mod.module_type == 'DAQ_Viewer':
@@ -446,7 +445,7 @@ class DAQ_Logging(QObject):
             logger.exception(str(e))
 
     def format_actuators_data(self, data_act: DataActuator):
-        data = data_mod.DataToExport(name=data_act.name, data=[data_act])
+        data = DataToExport(name=data_act.name, data=[data_act])
         self.do_save_continuous(data)
 
     def connect_actuators(self, connect=True):
@@ -508,7 +507,7 @@ class DAQ_Logging(QObject):
 
 
 def main():
-    from pymodaq.utils.gui_utils.utils import mkQApp
+    from pymodaq_gui.utils.utils import mkQApp
     from pymodaq.utils.gui_utils.loader_utils import load_dashboard_with_preset
 
     app = mkQApp('DAQLogger')
@@ -520,5 +519,6 @@ def main():
 
     return dashboard, extension, win
 
+
 if __name__ == '__main__':
     main()

pymodaq/{utils/db/db_logger → extensions/daq_logger/db}/db_logger.py

@@ -1,26 +1,27 @@
+from contextlib import contextmanager
 import logging
 import datetime
 from typing import List
 
-from pymodaq.utils.logger import set_logger, get_module_name, get_module_name
-from pymodaq.utils.config import Config
-from pymodaq.utils.data import DataToExport
-from qtpy import QtCore
-from contextlib import contextmanager
-
-from pymodaq.utils.db.db_logger.db_logger_models import Base, Data0D, Data1D, Data2D, LogInfo,\
-    Configuration, ControlModule
-from pymodaq.utils import daq_utils as utils
-from pymodaq.utils.gui_utils.utils import dashboard_submodules_params
-from pymodaq.utils.messenger import messagebox, deprecation_msg
-from pymodaq.utils.abstract.logger import AbstractLogger
-from pymodaq.utils.parameter import ParameterTree, Parameter
-from pymodaq.utils.managers.parameter_manager import ParameterManager
-
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 from sqlalchemy_utils import database_exists, create_database
 
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.config import Config
+
+from pymodaq_gui.h5modules.saving import dashboard_submodules_params
+from pymodaq_gui.messenger import messagebox
+from pymodaq_gui.managers.parameter_manager import ParameterManager
+
+from pymodaq_data.data import DataToExport
+
+
+from .db_logger_models import (Base, Data0D, Data1D, Data2D, LogInfo,
+                               Configuration, ControlModule)
+from ..abstract import AbstractLogger
+
+
 logger = set_logger(get_module_name(__file__))
 config = Config()
 

pymodaq/{utils/db/db_logger → extensions/daq_logger/db}/db_logger_models.py

@@ -3,6 +3,8 @@ from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import sessionmaker, relationship
 from sqlalchemy import Column, Integer, String, Float, ForeignKey
 from sqlalchemy.dialects.postgresql import ARRAY as Array
+
+
 Base = declarative_base()
 
 

pymodaq/{utils/h5modules → extensions/daq_logger}/h5logging.py

@@ -8,15 +8,14 @@ Created the 15/11/2022
 import logging
 import numpy as np
 
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils.config import Config
-from pymodaq.utils.managers.modules_manager import ModulesManager
-from pymodaq.utils.h5modules import module_saving, data_saving
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.config import Config
+from pymodaq_gui.h5modules.saving import H5Saver
+from pymodaq_data.data import DataToExport
 
-from pymodaq.utils.abstract.logger import AbstractLogger
-from pymodaq.utils import daq_utils as utils
-from .saving import H5Saver
-from pymodaq.utils.data import DataToExport
+from pymodaq.utils.managers.modules_manager import ModulesManager
+from pymodaq.utils.h5modules import module_saving
+from .abstract import AbstractLogger
 
 
 config = Config()

pymodaq/extensions/daq_scan.py

@@ -18,30 +18,29 @@ import numpy as np
 from qtpy import QtWidgets, QtCore, QtGui
 from qtpy.QtCore import QObject, Slot, QThread, Signal, QDateTime, QDate, QTime
 
-from pymodaq.utils import data as data_mod
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils.config import Config, get_set_preset_path
-from pymodaq.utils.parameter import ioxml
-from pymodaq.utils.plotting.data_viewers import ViewersEnum
-from pymodaq.utils.managers.parameter_manager import ParameterManager, Parameter, ParameterTree
-
-from pymodaq.utils import exceptions
-from pymodaq.utils.plotting.data_viewers.viewer2D import Viewer2D
-from pymodaq.utils.plotting.data_viewers.viewer1D import Viewer1D
-from pymodaq.utils.plotting.navigator import Navigator
-from pymodaq.utils.plotting.scan_selector import ScanSelector, SelectorItem
-from pymodaq.utils.scanner.scanner import Scanner, scanner_factory  #, adaptive, adaptive_losses
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.config import Config
+from pymodaq_utils import utils
+
+from pymodaq_data import data as data_mod
+from pymodaq_data.h5modules import data_saving
+
+from pymodaq_gui.parameter import ioxml
+from pymodaq_gui.plotting.data_viewers import ViewersEnum
+from pymodaq_gui.managers.parameter_manager import ParameterManager, Parameter, ParameterTree
+from pymodaq_gui.plotting.navigator import Navigator
+from pymodaq_gui.messenger import messagebox
+from pymodaq_gui import utils as gutils
+from pymodaq_gui.h5modules.saving import H5Saver
+
+from pymodaq.utils.scanner.scanner import Scanner
 from pymodaq.utils.managers.batchscan_manager import BatchScanner
 from pymodaq.utils.managers.modules_manager import ModulesManager
 from pymodaq.post_treatment.load_and_plot import LoaderPlotter
-from pymodaq.utils.messenger import messagebox
 from pymodaq.extensions.daq_scan_ui import DAQScanUI
-
-from pymodaq.utils import daq_utils as utils
-from pymodaq.utils import gui_utils as gutils
-from pymodaq.utils.h5modules.saving import H5Saver
-from pymodaq.utils.h5modules import module_saving, data_saving
-from pymodaq.utils.data import DataToExport, DataActuator
+from pymodaq.utils.h5modules import module_saving
+from pymodaq.utils.scanner.scan_selector import ScanSelector, SelectorItem
+from pymodaq.utils.data import DataActuator
 
 
 if TYPE_CHECKING:
@@ -54,6 +53,11 @@ logger = set_logger(get_module_name(__file__))
 SHOW_POPUPS = config('scan', 'show_popups')
 
 
+class DAQ_ScanException(Exception):
+    """Raised when an error occur within the DAQScan"""
+    pass
+
+
 class ScanDataTemp:
     """Convenience class to hold temporary data to be plotted in the live plots"""
     def __init__(self, scan_index: int, indexes: Tuple[int], data: data_mod.DataToExport):
@@ -589,7 +593,7 @@ class DAQScan(QObject, ParameterManager):
         positions = [posx, posy]
         positions = positions[:self.scanner.n_axes]
         actuators = self.modules_manager.actuators
-        dte = DataToExport(name="move_at")
+        dte = data_mod.DataToExport(name="move_at")
         for ind, pos in enumerate(positions):
             dte.append(DataActuator(actuators[ind].title, data=float(pos)))
 
@@ -745,7 +749,8 @@ class DAQScan(QObject, ParameterManager):
 
     def set_scan(self, scan=None) -> bool:
         """
-        Sets the current scan given the selected settings. Makes some checks, increments the h5 file scans.
+        Sets the current scan given the selected settings. Makes some checks,
+        increments the h5 file scans.
         In case the dialog is cancelled, return False and aborts the scan
         """
         try:
@@ -755,22 +760,25 @@ class DAQScan(QObject, ParameterManager):
 
             is_oversteps = self.scanner.set_scan()
             if is_oversteps:
-                messagebox(text=f"An error occurred when establishing the scan steps. Actual settings "
-                                f"gives approximately {int(self.scanner.n_steps)} steps."
-                                f" Please check the steps number "
-                                f"limit in the config file ({config['scan']['steps_limit']}) or modify"
-                                f" your scan settings.")
+                messagebox(
+                    text=f"An error occurred when establishing the scan steps. Actual settings "
+                         f"gives approximately {int(self.scanner.n_steps)} steps."
+                         f" Please check the steps number "
+                         f"limit in the config file ({config['scan']['steps_limit']}) or modify"
+                         f" your scan settings.")
 
             if self.modules_manager.Nactuators != self.scanner.n_axes:
-                messagebox(text="There are not enough or too much selected move modules for this scan")
+                messagebox(
+                    text="There are not enough or too much selected move modules for this scan")
                 return False
 
             if self.scanner.scan_sub_type == 'Adaptive':
                 #todo include this in scanners objects for the adaptive scanners
                 if len(self.modules_manager.get_selected_probed_data('0D')) == 0:
-                    messagebox(text="In adaptive mode, you have to pick a 0D signal from which the algorithm will"
-                                    " determine the next positions to scan, see 'probe_data' in the modules selector"
-                                    " panel")
+                    messagebox(
+                        text="In adaptive mode, you have to pick a 0D signal from which the "
+                             "algorithm will determine the next positions to scan, see 'probe_data'"
+                             " in the modules selector panel")
                     return False
 
             self.ui.n_scan_steps = self.scanner.n_steps
@@ -778,11 +786,11 @@ class DAQScan(QObject, ParameterManager):
             # check if the modules are initialized
             for module in self.modules_manager.actuators:
                 if not module.initialized_state:
-                    raise exceptions.DAQ_ScanException('module ' + module.title + " is not initialized")
+                    raise DAQ_ScanException('module ' + module.title + " is not initialized")
 
             for module in self.modules_manager.detectors:
                 if not module.initialized_state:
-                    raise exceptions.DAQ_ScanException('module ' + module.title + " is not initialized")
+                    raise DAQ_ScanException('module ' + module.title + " is not initialized")
 
             self.ui.enable_start_stop(True)
             return True
@@ -1166,7 +1174,7 @@ class DAQScanAcquisition(QObject):
 
 
 def main():
-    from pymodaq.utils.gui_utils.utils import mkQApp
+    from pymodaq_gui.utils.utils import mkQApp
     from pymodaq.utils.gui_utils.loader_utils import load_dashboard_with_preset
 
     app = mkQApp('DAQScan')