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

pymodaq/examples/custom_app.py

@@ -1,25 +1,22 @@
-from collections import OrderedDict
-import datetime
-import numpy as np
 
-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
+import datetime
 
 from qtpy import QtWidgets
 from qtpy.QtCore import Slot, QDate, QThread
 
-from pymodaq.utils import daq_utils as utils
-from pymodaq.utils.parameter import ioxml
-from pymodaq.control_modules.daq_viewer import DAQ_Viewer
-from pymodaq.utils.plotting.data_viewers.viewer0D import Viewer0D
+from pymodaq_utils.config import Config
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_gui.utils.custom_app import CustomApp
+from pymodaq_gui.utils.dock import DockArea, Dock
+from pymodaq_gui.utils.file_io import select_file
+from pymodaq_gui.parameter import ioxml
+from pymodaq_gui.plotting.data_viewers.viewer0D import Viewer0D
+from pymodaq_gui.h5modules.browsing import H5Browser
+from pymodaq_gui.h5modules.saving import H5Saver
+from pymodaq_data.h5modules.data_saving import DataToExportSaver
+from pymodaq_data.data import DataToExport
 
-from pymodaq.utils.h5modules.browsing import H5Browser
-from pymodaq.utils.h5modules.saving import H5Saver
-from pymodaq.utils.h5modules.data_saving import DataToExportSaver
-from pymodaq.utils.data import DataToExport
+from pymodaq.control_modules.daq_viewer import DAQ_Viewer
 
 
 config = Config()

pymodaq/examples/custom_viewer.py

@@ -1,10 +1,10 @@
-from pymodaq.utils.gui_utils.widgets.table import SpinBoxDelegate
-from  pymodaq.utils.parameter.utils import get_widget_from_tree
-from pymodaq.utils.plotting.data_viewers.viewer2D import Viewer2D
+from pymodaq_gui.utils.widgets.table import SpinBoxDelegate
+from  pymodaq_gui.parameter.utils import get_widget_from_tree
+from pymodaq_gui.plotting.data_viewers.viewer2D import Viewer2D
 from pymodaq.utils import gui_utils as gutils
-from pyqtgraph.dockarea import Dock
-from pymodaq.utils.parameter import ParameterTree, Parameter
-from pymodaq.utils.parameter.pymodaq_ptypes.tableview import TableViewCustom
+from pymodaq_gui.utils import Dock
+from pymodaq_gui.parameter import ParameterTree, Parameter
+from pymodaq_gui.parameter.pymodaq_ptypes.tableview import TableViewCustom
 from pymodaq.utils.scanner.scanners.tabular import TableModelTabular
 from qtpy.QtCore import QObject, Qt, Slot
 from qtpy import QtWidgets

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/parameter_ex.py

@@ -4,58 +4,74 @@ Examples of custome parameter types derived from pyqtgraph
 """
 import sys
 
-import pymodaq.utils.gui_utils.widgets.table
+import pymodaq_gui.utils.widgets.table
 from qtpy import QtWidgets, QtCore
-from pymodaq.utils.parameter import ParameterTree, Parameter
+
 from collections import OrderedDict
-from pymodaq.utils.managers.parameter_manager import ParameterManager
+from pymodaq_gui.managers.parameter_manager import ParameterManager
 
 
 class ParameterEx(ParameterManager):
     params = [
         {'title': 'Groups:', 'name': 'groups', 'type': 'group', 'children': [
             {'title': 'A visible group:', 'name': 'agroup', 'type': 'group', 'children': []},
-            {'title': 'An hidden group:', 'name': 'bgroup', 'type': 'group', 'children': [], 'visible': False},  # this
+            {'title': 'An hidden group:', 'name': 'bgroup', 'type': 'group', 'children': [],
+             'visible': False},  # this
             # visible option is not available in usual pyqtgraph group
         ]},
 
         {'title': 'Numbers:', 'name': 'numbers', 'type': 'group', 'children': [
             {'title': 'Standard float', 'name': 'afloat', 'type': 'float', 'value': 20., 'min': 1.,
              'tip': 'displays this text as a tooltip'},
-            {'title': 'Linear Slide float', 'name': 'linearslidefloat', 'type': 'slide', 'value': 50, 'default': 50,
+            {'title': 'Linear Slide float', 'name': 'linearslidefloat', 'type': 'slide',
+             'value': 50, 'default': 50,
              'min': 0,
              'max': 123, 'subtype': 'linear'},
-            {'title': 'Linear int Slide', 'name': 'linearslideint', 'type': 'slide', 'value': 50, 'default': 50,
+            {'title': 'Linear int Slide', 'name': 'linearslideint', 'type': 'slide',
+             'value': 50, 'default': 50, 'step':1,
              'min': 0,
              'max': 123, 'subtype': 'linear', 'int': True},
-            {'title': 'Log Slide float', 'name': 'logslidefloat', 'type': 'slide', 'value': 50, 'default': 50,
+            {'title': 'Linear Slide with suffix', 'name': 'linearslidewithsuffixandsiPrefix',
+             'type': 'slide', 'value': 50, 'default': 50,
+             'min': 0,
+             'max': 1e6, 'subtype': 'linear','suffix':'V','siPrefix':True},             
+            {'title': 'Log Slide float', 'name': 'logslidefloat', 'type': 'slide',
+             'value': 50, 'default': 50,
              'min': 1e-5,
-             'max': 1e5, 'subtype': 'log'},
+             'max': 1e5, 'subtype': 'log','suffix':'V','siPrefix':True},
         ]},
 
         {'title': 'Booleans:', 'name': 'booleans', 'type': 'group', 'children': [
             {'title': 'Standard bool', 'name': 'abool', 'type': 'bool', 'value': True},
-            {'title': 'bool push', 'name': 'aboolpush', 'type': 'bool_push', 'value': True, 'label': 'action'},
-            {'title': 'A led', 'name': 'aled', 'type': 'led', 'value': False, 'tip': 'a led you cannot toggle'},
-            {'title': 'A led', 'name': 'anotherled', 'type': 'led_push', 'value': True, 'tip': 'a led you can toggle'},
+            {'title': 'bool push', 'name': 'aboolpush', 'type': 'bool_push', 'value': True,
+             'label': 'action'},
+            {'title': 'A led', 'name': 'aled', 'type': 'led', 'value': False,
+             'tip': 'a led you cannot toggle'},
+            {'title': 'A led', 'name': 'anotherled', 'type': 'led_push', 'value': True,
+             'tip': 'a led you can toggle'},
         ]},
 
         {'title': 'DateTime:', 'name': 'datetimes', 'type': 'group', 'children': [
-            {'title': 'Time:', 'name': 'atime', 'type': 'time', 'value': QtCore.QTime.currentTime()},
-            {'title': 'Date:', 'name': 'adate', 'type': 'date', 'value': QtCore.QDate.currentDate(),
+            {'title': 'Time:', 'name': 'atime', 'type': 'time',
+             'value': QtCore.QTime.currentTime()},
+            {'title': 'Date:', 'name': 'adate', 'type': 'date',
+             'value': QtCore.QDate.currentDate(),
              'format': 'dd/MM/yyyy'},
             {'title': 'DateTime:', 'name': 'adatetime', 'type': 'date_time',
              'value': QtCore.QDateTime(QtCore.QDate.currentDate(), QtCore.QTime.currentTime()),
              'format': 'MM/dd/yyyy hh:mm', 'tip': 'displays this text as a tooltip'},
         ]},
-        {'title': 'An action', 'name': 'action', 'type': 'action'},  # action whose displayed text corresponds to title
+        {'title': 'An action', 'name': 'action', 'type': 'action'},
+        # action whose displayed text corresponds to title
 
         {'title': 'Lists:', 'name': 'lists', 'type': 'group', 'children': [
             {'title': 'Standard list:', 'name': 'alist', 'type': 'list',
              'limits': ['a value', 'another one'], 'value': 'a value'},
             {'title': 'List with add:', 'name': 'anotherlist', 'type': 'list',
              'limits': ['a value', 'another one'], 'value': 'a value',
-             'show_pb': True, 'tip': 'when using the "show_pb" option, displays a plus button to add elt to the list'},
+             'show_pb': True,
+             'tip': 'when using the "show_pb" option, displays a plus '
+                    'button to add elt to the list'},
             {'title': 'List defined from a dict:', 'name': 'dict_list', 'type': 'list',
              'limits': {'xaxis': 0, 'yaxis': [0, 1, 2]},
              'value': 'yaxis',
@@ -64,9 +80,11 @@ class ParameterEx(ParameterManager):
              },
         ]},
         {'title': 'Browsing files:', 'name': 'browser', 'type': 'group', 'children': [
-            {'title': 'Look for a file:', 'name': 'afile', 'type': 'browsepath', 'value': '', 'filetype': True,
+            {'title': 'Look for a file:', 'name': 'afile', 'type': 'browsepath', 'value': '',
+             'filetype': True,
              'tip': 'If filetype is True select a file otherwise a directory'},
-            {'title': 'Look for a dir:', 'name': 'adir', 'type': 'browsepath', 'value': '', 'filetype': False,
+            {'title': 'Look for a dir:', 'name': 'adir', 'type': 'browsepath', 'value': '',
+             'filetype': False,
              'tip': 'If filetype is True select a file otherwise a directory'},
 
         ]},
@@ -79,19 +97,24 @@ class ParameterEx(ParameterManager):
              'tip': 'If show_pb is True, user can add items to the list', 'show_pb': True,},
             {'title': 'Removable items', 'name': 'itemsbisbis', 'type': 'itemselect',
              'value': dict(all_items=['item1', 'item2', 'item3'], selected=['item2']),
-             'tip': 'If show_mb is True, user can remove selected items from the list', 'show_mb': True,},            
+             'tip': 'If show_mb is True, user can remove selected items from the list',
+             'show_mb': True,},
             {'title': 'Checkable items', 'name': 'itemscheckable', 'type': 'itemselect',
              'value': dict(all_items=['item1', 'item2', 'item3'], selected=['item2']),
-             'tip': 'If checkbox is True, user can select item by checking/unchecking items. Remove items is still used with standard selections',
+             'tip': 'If checkbox is True, user can select item by checking/unchecking items.'
+                    ' Remove items is still used with standard selections',
              'show_pb': True, 'checkbox': True, 'show_mb': True,},                        
             {'title': 'Dragable items', 'name': 'itemsdragablecheckable', 'type': 'itemselect',
              'value': dict(all_items=['item1', 'item2', 'item3'], selected=['item2']),
-             'tip': 'If dragdrop is True, user can drag or drop items inside the list', 'checkbox': True, 'dragdrop': True}, 
+             'tip': 'If dragdrop is True, user can drag or drop items inside the list',
+             'checkbox': True, 'dragdrop': True},
         ]},  
         {'title': 'Plain text:', 'name': 'texts', 'type': 'group', 'children': [
-            {'title': 'Standard str', 'name': 'atte', 'type': 'str', 'value': 'this is a string you can edit'},
+            {'title': 'Standard str', 'name': 'atte', 'type': 'str',
+             'value': 'this is a string you can edit'},
             {'title': 'Plain text', 'name': 'text', 'type': 'text', 'value': 'this is some text'},
-            {'title': 'Plain text', 'name': 'textpb', 'type': 'text_pb', 'value': 'this is some text',
+            {'title': 'Plain text', 'name': 'textpb', 'type': 'text_pb',
+             'value': 'this is some text',
              'tip': 'If text_pb type is used, user can add text to the parameter'},
         ]},
 
@@ -99,9 +122,11 @@ class ParameterEx(ParameterManager):
             {'title': 'Table widget', 'name': 'tablewidget', 'type': 'table', 'value':
                 OrderedDict(key1='data1', key2=24), 'header': ['keys', 'limits'], 'height': 100},
             {'title': 'Table view', 'name': 'tabular_table', 'type': 'table_view',
-             'delegate': pymodaq.utils.gui_utils.widgets.table.SpinBoxDelegate, 'menu': True,
-             'value': pymodaq.utils.gui_utils.widgets.table.TableModel([[0.1, 0.2, 0.3]], ['value1', 'value2', 'value3']),
-             'tip': 'The advantage of the Table model lies in its modularity.\n For concrete examples see the'
+             'delegate': pymodaq_gui.utils.widgets.table.SpinBoxDelegate, 'menu': True,
+             'value': pymodaq_gui.utils.widgets.table.TableModel([[0.1, 0.2, 0.3]],
+                                                                 ['value1', 'value2', 'value3']),
+             'tip': 'The advantage of the Table model lies in its modularity.\n '
+                    'For concrete examples see the'
                     'TableModelTabular and the TableModelSequential custom models in the'
                     ' pymodaq.utils.scanner module'},
         ]},  # The advantage of the Table model lies in its modularity for concrete examples see the

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,24 +6,27 @@ 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 configmod
+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 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
 
 
 EXTENSION_NAME = 'BayesianOptimisation'

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'\
@@ -53,22 +55,17 @@ class QtConsole(RichJupyterWidget):
         self.kernel_manager.kernel.shell.push(variable_dict)
 
 
-def main(init_qt=True):
-    import sys
+def main():
+    from pymodaq_gui.utils.utils import mkQApp
 
-    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('Console')
 
     prog = QtConsole(style_sheet=config('style', 'syntax_highlighting'),
                      syntax_style=config('style', 'syntax_highlighting'),
                      custom_banner=BANNER,
                      )
     prog.show()
-    if init_qt:
-        sys.exit(app.exec_())
+    app.exec()
     return prog
 
 

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

@@ -11,40 +11,40 @@ 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.custom_app import CustomApp
+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_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 DataToExport, DataActuator, DataWithAxes
+from pymodaq.utils.data import DataActuator, DataToExport
 
 
 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:
@@ -204,17 +204,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 +241,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 +446,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,37 +508,17 @@ class DAQ_Logging(QObject):
 
 
 def main():
-    from pymodaq.dashboard import DashBoard
-    from pathlib import Path
-    from pymodaq.utils.gui_utils.dock import DockArea
-
-    config = Config()
-    app = QtWidgets.QApplication(sys.argv)
-    if config('style', 'darkstyle'):
-        import qdarkstyle
-        app.setStyleSheet(qdarkstyle.load_stylesheet())
-
-    win = QtWidgets.QMainWindow()
-    area = DockArea()
-    win.setCentralWidget(area)
-    win.resize(1000, 500)
-    win.setWindowTitle('PyMoDAQ Dashboard')
-
-    # win.setVisible(False)
-    prog = DashBoard(area)
-    file = Path(get_set_preset_path()).joinpath(f"{config('presets', 'default_preset_for_logger')}.xml")
-    if file.exists():
-        prog.set_preset_mode(file)
-        prog.load_log_module()
-    else:
-        msgBox = QtWidgets.QMessageBox()
-        msgBox.setText(f"The default file specified in the configuration file does not exists!\n"
-                       f"{file}\n"
-                       f"Impossible to load the Logger Module")
-        msgBox.setStandardButtons(msgBox.Ok)
-        ret = msgBox.exec()
-
-    sys.exit(app.exec_())
+    from pymodaq_gui.utils.utils import mkQApp
+    from pymodaq.utils.gui_utils.loader_utils import load_dashboard_with_preset
+
+    app = mkQApp('DAQLogger')
+    preset_file_name = config('presets', f'default_preset_for_logger')
+
+    dashboard, extension, win = load_dashboard_with_preset(preset_file_name, 'DAQLogger')
+
+    app.exec()
+
+    return dashboard, extension, win
 
 
 if __name__ == '__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()