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

pymodaq/utils/exceptions.py

@@ -19,10 +19,6 @@ class MasterSlaveError(Exception):
     pass
 
 
-class ViewerError(Exception):
-    pass
-
-
 class ExpectedError(Exception):
     """Raised in the tests made for pymodaq plugins"""
     pass

pymodaq/utils/gui_utils/__init__.py

@@ -1,10 +1,10 @@
-from .dock import Dock, DockArea
-from .list_picker import ListPicker
-from .custom_app import CustomApp
-from .file_io import select_file
-from .widgets.table import TableView, TableModel, SpinBoxDelegate, BooleanDelegate
-from .widgets.push import PushButtonIcon, EditPush, EditPushRel, EditPushInfo
-from .widgets.qled import QLED
-from .widgets.spinbox import QSpinBox_ro
+from pymodaq_gui.utils.dock import Dock, DockArea
+from pymodaq_gui.utils.list_picker import ListPicker
+from pymodaq_gui.utils.custom_app import CustomApp
+from pymodaq_gui.utils.file_io import select_file
+from pymodaq_gui.utils.widgets.table import TableView, TableModel, SpinBoxDelegate, BooleanDelegate
+from pymodaq_gui.utils.widgets.push import PushButtonIcon, EditPush, EditPushRel, EditPushInfo
+from pymodaq_gui.utils.widgets.qled import QLED
+from pymodaq_gui.utils.widgets.spinbox import QSpinBox_ro
 
 from .utils import get_splash_sc

pymodaq/utils/gui_utils/loader_utils.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+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
+
+
+def load_dashboard_with_preset(preset_name: str, extension_name: str):
+    win = QtWidgets.QMainWindow()
+    area = DockArea()
+    win.setCentralWidget(area)
+    win.resize(1000, 500)
+    win.setWindowTitle('PyMoDAQ Dashboard')
+    win.show()
+
+    # win.setVisible(False)
+    dashboard = DashBoard(area)
+
+    file = Path(get_set_preset_path()).joinpath(f"{preset_name}.xml")
+
+    if file is not None and file.exists():
+        dashboard.set_preset_mode(file)
+        if extension_name == 'DAQScan':
+            extension = dashboard.load_scan_module()
+        elif extension_name == 'DAQLogger':
+            extension = dashboard.load_log_module()
+        else:
+            extension = dashboard.load_extension_from_name(extension_name)
+    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 {extension_name} extension")
+        msgBox.setStandardButtons(msgBox.Ok)
+        ret = msgBox.exec()
+    return dashboard, extension, win

pymodaq/utils/gui_utils/utils.py

@@ -4,150 +4,18 @@ 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.config import Config
+from pymodaq_utils.logger import set_logger, get_module_name
 
 config = Config()
+logger = set_logger(get_module_name(__file__))
 
 
-dashboard_submodules_params = [
-    {'title': 'Save 2D datas and above:', 'name': 'save_2D', 'type': 'bool', 'value': True},
-    {'title': 'Save raw datas only:', 'name': 'save_raw_only', 'type': 'bool', 'value': True, 'tooltip':
-        'if True, will not save extracted ROIs used to do live plotting, only raw datas will be saved'},
-    {'title': 'Do Save:', 'name': 'do_save', 'type': 'bool', 'default': False, 'value': False},
-    {'title': 'N saved:', 'name': 'N_saved', 'type': 'int', 'default': 0, 'value': 0, 'visible': False},
-]
-
 def get_splash_sc():
     here = Path(__file__)
-    splash_sc = QtWidgets.QSplashScreen(QtGui.QPixmap(str(here.parent.parent.parent.joinpath('splash.png'))),
-                                        Qt.WindowStaysOnTopHint)
+    splash_sc = QtWidgets.QSplashScreen(
+        QtGui.QPixmap(str(here.parent.parent.parent.joinpath('splash.png'))),
+        Qt.WindowStaysOnTopHint)
     return splash_sc
 
 
-def clickable(widget):
-    class Filter(QObject):
-        clicked = Signal()
-
-        def eventFilter(self, obj, event):
-            if obj == widget:
-                if event.type() == QEvent.MouseButtonRelease:
-                    if obj.rect().contains(event.pos()):
-                        self.clicked.emit()
-                        # The developer can opt for .emit(obj) to get the object within the slot.
-                        return True
-            return False
-
-    filter = Filter(widget)
-    widget.installEventFilter(filter)
-    return filter.clicked
-
-
-def h5tree_to_QTree(base_node, base_tree_elt=None, pixmap_items=[]):
-    """
-        | Convert a loaded h5 file to a QTreeWidgetItem element structure containing two columns.
-        | The first is the name of the h5 current node, the second is the path of the node in the h5 structure.
-        |
-        | Recursive function discreasing on base_node.
-
-        ==================   ======================================== ===============================
-        **Parameters**        **Type**                                 **Description**
-
-          *h5file*            instance class File from tables module   loaded h5 file
-
-          *base_node*         pytables h5 node                         parent node
-
-          *base_tree_elt*     QTreeWidgetItem                          parent QTreeWidgetItem element
-        ==================   ======================================== ===============================
-
-        Returns
-        -------
-        QTreeWidgetItem
-            h5 structure copy converted into QtreeWidgetItem structure.
-
-        See Also
-        --------
-        h5tree_to_QTree
-
-    """
-
-    if base_tree_elt is None:
-        base_tree_elt = QtWidgets.QTreeWidgetItem([base_node.name, "", base_node.path])
-    for node_name, node in base_node.children().items():
-        child = QtWidgets.QTreeWidgetItem([node_name, "", node.path])
-        if 'pixmap' in node.attrs.attrs_name:
-            pixmap_items.append(dict(node=node, item=child))
-        klass = node.attrs['CLASS']
-        if klass == 'GROUP':
-            h5tree_to_QTree(node, child, pixmap_items)
-
-        base_tree_elt.addChild(child)
-    return base_tree_elt, pixmap_items
-
-
-def set_enable_recursive(children, enable=False):
-    """Apply the enable state on all children widgets, do it recursively
-
-    Parameters
-    ----------
-    children: (list) elements children ofa pyqt5 element
-    enable: (bool) set enabled state (True) of all children widgets
-    """
-    for child in children:
-        if not children:
-            return
-        elif isinstance(child, QtWidgets.QSpinBox) or isinstance(child, QtWidgets.QComboBox) or \
-                isinstance(child, QtWidgets.QPushButton) or isinstance(child, QtWidgets.QListWidget):
-            child.setEnabled(enable)
-        else:
-            set_enable_recursive(child.children(), enable)
-
-
-def widget_to_png_to_bytes(widget, keep_aspect=True, width=200, height=100):
-    """
-    Renders the widget content in a png format as a bytes string
-    Parameters
-    ----------
-    widget: (QWidget) the widget to render
-    keep_aspect: (bool) if True use width and the widget aspect ratio to calculate the height
-                        if False use set values of width and height to produce the png
-    width: (int) the rendered width of the png
-    height: (int) the rendered width of the png
-
-    Returns
-    -------
-    binary string
-
-    """
-    png = widget.grab().toImage()
-    wwidth = widget.width()
-    wheight = widget.height()
-    if keep_aspect:
-        height = width * wheight / wwidth
-
-    png = png.scaled(int(width), int(height), QtCore.Qt.KeepAspectRatio)
-    buffer = QtCore.QBuffer()
-    buffer.open(QtCore.QIODevice.WriteOnly)
-    png.save(buffer, "png")
-    return buffer.data().data()
-
-
-def pngbinary2Qlabel(databinary, scale_height: int = None):
-    buff = QBuffer()
-    buff.open(QIODevice.WriteOnly)
-    buff.write(databinary)
-    dat = buff.data()
-    pixmap = QtGui.QPixmap()
-    pixmap.loadFromData(dat, 'PNG')
-    if scale_height is not None and isinstance(scale_height, int):
-        pixmap = pixmap.scaledToHeight(scale_height)
-    label = QtWidgets.QLabel()
-    label.setPixmap(pixmap)
-    return label
-
-
-def start_qapplication() -> QtWidgets.QApplication:
-    app = QtWidgets.QApplication(sys.argv)
-    if config('style', 'darkstyle'):
-        import qdarkstyle
-        app.setStyleSheet(qdarkstyle.load_stylesheet(qdarkstyle.DarkPalette))
-    return app

pymodaq/utils/h5modules/__init__.py

@@ -1,6 +1,2 @@
-from . import browsing
-from .utils import register_exporter, register_exporters
-
-register_exporters()
 
 

pymodaq/utils/h5modules/module_saving.py

@@ -12,19 +12,20 @@ import xml.etree.ElementTree as ET
 
 import numpy as np
 
-from pymodaq.utils.abstract import ABCMeta, abstract_attribute, abstractmethod
-from pymodaq.utils.daq_utils import capitalize
-from pymodaq.utils.data import Axis, DataDim, DataWithAxes, DataToExport, DataDistribution
-from .saving import H5SaverLowLevel
-from .backends import GROUP, CARRAY, Node, GroupType
-from .data_saving import DataToExportSaver, AxisSaverLoader, DataToExportTimedSaver, DataToExportExtendedSaver
-from pymodaq.utils.parameter import ioxml
+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
+from pymodaq_data.h5modules.saving import H5SaverLowLevel
+from pymodaq_data.h5modules.backends import GROUP, CARRAY, Node, GroupType
+from pymodaq_data.h5modules.data_saving import (DataToExportSaver, AxisSaverLoader,
+                                                DataToExportTimedSaver, DataToExportExtendedSaver)
+from pymodaq_gui.parameter import ioxml
 
 if TYPE_CHECKING:
     from pymodaq.extensions.daq_scan import DAQScan
     from pymodaq.control_modules.daq_viewer import DAQ_Viewer
     from pymodaq.control_modules.daq_move import DAQ_Move
-    from pymodaq.utils.h5modules.h5logging import H5Logger
+    from pymodaq.extensions.daq_logger.h5logging import H5Logger
 
 
 class ModuleSaver(metaclass=ABCMeta):
@@ -304,6 +305,12 @@ class ScanSaver(ModuleSaver):
             if hasattr(module, 'module_and_data_saver'):
                 module.module_and_data_saver.h5saver = self.h5saver
 
+    def forget_h5(self):
+        for module in self._module.modules_manager.modules_all:
+            if hasattr(module, 'module_and_data_saver'):
+                module.module_and_data_saver.h5saver = None
+        self.h5saver.flush()
+
     def get_set_node(self, where: Union[Node, str] = None, new=False) -> GROUP:
         """Get the last group scan node
 

pymodaq/utils/leco/__init__.py

@@ -1,5 +1,5 @@
-from pymodaq.utils.logger import set_logger
-from pymodaq.utils.config import Config
+from pymodaq_utils.logger import set_logger
+from pymodaq_utils.config import Config
 
 logger = set_logger('pymodaq')
 config = Config()  # to ckeck for config file existence, otherwise create one

pymodaq/utils/leco/daq_move_LECODirector.py

@@ -12,8 +12,8 @@ from typing import Union
 from pymodaq.control_modules.move_utility_classes import (DAQ_Move_base, comon_parameters_fun, main,
                                                           DataActuatorType, DataActuator)
 
-from pymodaq.utils.daq_utils import ThreadCommand
-from pymodaq.utils.parameter import Parameter
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_gui.parameter import Parameter
 
 from pymodaq.utils.leco.leco_director import LECODirector, leco_parameters
 from pymodaq.utils.leco.director_utils import ActuatorDirector

pymodaq/utils/leco/daq_xDviewer_LECODirector.py

@@ -5,8 +5,8 @@ from easydict import EasyDict as edict
 
 from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base, comon_parameters, main
 
-from pymodaq.utils.daq_utils import ThreadCommand, getLineInfo
-from pymodaq.utils.parameter import Parameter
+from pymodaq_utils.utils import ThreadCommand, getLineInfo
+from pymodaq_gui.parameter import Parameter
 from pymodaq.utils.tcp_ip.serializer import DeSerializer
 
 from pymodaq.utils.leco.leco_director import LECODirector, leco_parameters

pymodaq/utils/leco/director_utils.py

@@ -8,8 +8,8 @@ from typing import Optional, Union, List
 
 from pyleco.directors.director import Director
 
-import pymodaq.utils.parameter.utils as putils
-from pymodaq.utils.parameter import Parameter, ioxml
+import pymodaq_gui.parameter.utils as putils
+from pymodaq_gui.parameter import Parameter, ioxml
 from pymodaq.control_modules.move_utility_classes import DataActuator
 from pymodaq.utils.leco.utils import serialize_object
 

pymodaq/utils/leco/leco_director.py

@@ -3,10 +3,10 @@ import random
 
 from typing import Callable, Sequence, List
 
-import pymodaq.utils.parameter.utils as putils
+import pymodaq_gui.parameter.utils as putils
 # object used to send info back to the main thread:
-from pymodaq.utils.daq_utils import ThreadCommand
-from pymodaq.utils.parameter import Parameter
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_gui.parameter import Parameter
 
 from pymodaq.utils.leco.director_utils import GenericDirector
 from pymodaq.utils.leco.pymodaq_listener import PymodaqListener

pymodaq/utils/leco/pymodaq_listener.py

@@ -14,8 +14,8 @@ from pyleco.core import COORDINATOR_PORT
 from pyleco.utils.listener import Listener, PipeHandler
 from qtpy.QtCore import QObject, Signal  # type: ignore
 
-from pymodaq.utils.daq_utils import ThreadCommand
-from pymodaq.utils.parameter import ioxml
+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
 

pymodaq/utils/leco/utils.py

@@ -4,7 +4,7 @@ from typing import Any, Union, get_args
 
 # 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.logger import set_logger
+from pymodaq_utils.logger import set_logger
 
 
 logger = set_logger('leco_utils')

pymodaq/utils/logger.py

@@ -1,78 +1,6 @@
-# -*- coding: utf-8 -*-
-"""
-Created the 27/10/2022
+from pymodaq_utils.logger import set_logger, get_module_name, get_set_config_dir, get_base_logger
 
-@author: Sebastien Weber
-"""
-import logging
-import warnings
-from logging.handlers import TimedRotatingFileHandler
-from pathlib import Path
+from pymodaq_utils.warnings import deprecation_msg
 
-from pymodaq.utils.config import get_set_config_dir, Config
-
-config = Config()
-
-
-def set_logger(logger_name, add_handler=False, base_logger=False, add_to_console=False, log_level=None,
-               logger_base_name='pymodaq') -> logging.Logger:
-    """defines a logger of a given name and eventually add an handler to it
-
-    Parameters
-    ----------
-    logger_name: (str) the name of the logger (usually it is the module name as returned by get_module_name
-    add_handler (bool) if True adds a TimedRotatingFileHandler to the logger instance (should be True if logger set from
-                main app
-    base_logger: (bool) specify if this is the parent logger (usually where one defines the handler)
-
-    Returns
-    -------
-    logger: (logging.Logger) logger instance
-    See Also
-    --------
-    get_module_name, logging.handlers.TimedRotatingFileHandler
-    """
-    if not base_logger:
-        logger_name = f'{logger_base_name}.{logger_name}'
-
-    logger = logging.getLogger(logger_name)
-    log_path = get_set_config_dir('log', user=True)
-    if log_level is None:
-        log_level = config('general', 'debug_level')
-    logger.setLevel(log_level)
-    if add_handler:
-        log_file_path = log_path.joinpath(f'{logger_base_name}.log')
-        if not log_file_path.is_file():
-            log_file_path.touch(mode=0o777)
-        handler = TimedRotatingFileHandler(log_file_path, when='midnight')
-        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-        handler.setFormatter(formatter)
-        logger.addHandler(handler)
-
-        logging.captureWarnings(True)
-        # only catch DeprecationWarning in DEBUG level
-        if log_level == 'DEBUG':
-            warnings.filterwarnings('default', category=DeprecationWarning)
-        else:
-            warnings.filterwarnings('ignore', category=DeprecationWarning)
-        warnings_logger = logging.getLogger("py.warnings")
-        warnings_logger.addHandler(handler)
-
-    if add_to_console:
-        console_handler = logging.StreamHandler()
-        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
-        console_handler.setFormatter(formatter)
-        logger.addHandler(console_handler)
-    return logger
-
-
-def get_base_logger(logger: logging.Logger) -> logging.Logger:
-    while logger.name != 'pymodaq':
-        logger = logger.parent
-    return logger
-
-
-def get_module_name(module__file__path):
-    """from the full path of a module extract its name"""
-    path = Path(module__file__path)
-    return path.stem
+deprecation_msg('Importing logger stuff from pymodaq is deprecated in pymodaq>5.0.0,'
+                'please use the pymodaq_utils package')

pymodaq/utils/managers/batchscan_manager.py

@@ -1,29 +1,26 @@
+from collections import OrderedDict
+from pathlib import Path
+import sys
 from typing import List
 
-import pymodaq.utils.config
-import pymodaq.utils.gui_utils.dock
-import pymodaq.utils.gui_utils.file_io
-import pymodaq.utils.messenger
 from qtpy import QtWidgets, QtCore
-import sys
-import os
 
-from pymodaq.utils.managers.parameter_manager import ParameterManager
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils import config as config_mod
+
+from pymodaq_gui.managers.parameter_manager import ParameterManager
+from pymodaq_gui.utils import Dock, file_io, DockArea
+from pymodaq_gui.parameter import ioxml
+from pymodaq_gui.messenger import messagebox
+
 from pymodaq.utils.managers.modules_manager import ModulesManager
-from pymodaq.utils.gui_utils import Dock
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils import config as config_mod
-from pymodaq.utils.parameter import ioxml
 from pymodaq.utils.scanner import Scanner
 from pymodaq.utils.scanner.scan_factory import ScannerBase
-from pymodaq.utils.scanner.utils import ScanType #, adaptive_losses
-from pathlib import Path
-from collections import OrderedDict
-from pymodaq.utils.messenger import messagebox
+from pymodaq.utils.config import get_set_batch_path
 
 logger = set_logger(get_module_name(__file__))
 
-batch_path = config_mod.get_set_batch_path()
+batch_path = get_set_batch_path()
 
 params = [
     {'title': 'Actuators/Detectors Selection', 'name': 'modules', 'type': 'group', 'children': [
@@ -92,7 +89,7 @@ class BatchManager(ParameterManager):
 
         """
         if filename is None or filename is False:
-            filename = pymodaq.utils.gui_utils.file_io.select_file(start_path=self.batch_path, save=False, ext='xml')
+            filename = file_io.select_file(start_path=self.batch_path, save=False, ext='xml')
             if filename == '':
                 return
 
@@ -301,7 +298,7 @@ class BatchScanner(QtCore.QObject):
 
     def load_file(self, filepath=None):
         if filepath is None:
-            path = pymodaq.utils.gui_utils.file_io.select_file(start_path=batch_path, save=False, ext='xml')
+            path = file_io.select_file(start_path=batch_path, save=False, ext='xml')
             if path != '':
                 filepath = path
             else:
@@ -319,7 +316,7 @@ def main_batch_scanner():
     from pymodaq.control_modules.mocks import MockDAQMove, MockDAQViewer
     app = QtWidgets.QApplication(sys.argv)
     win = QtWidgets.QMainWindow()
-    area = pymodaq.utils.gui_utils.dock.DockArea()
+    area = DockArea()
     win.setCentralWidget(area)
 
     # prog = BatchManager(msgbox=False, actuators=['Xaxis', 'Yaxis'], detectors=['Det0D', 'Det1D'])

pymodaq/utils/managers/modules_manager.py

@@ -5,12 +5,16 @@ from qtpy.QtCore import QObject, Signal, Slot, QThread
 from qtpy import QtWidgets
 import time
 
-from pymodaq.utils.logger import set_logger, get_module_name, get_module_name
-from pymodaq.utils import daq_utils as utils
-from pymodaq.utils.config import Config
-from pymodaq.utils.data import DataToExport, DataFromPlugins, DataActuator
-from pyqtgraph.parametertree import Parameter, ParameterTree
-from pymodaq.utils.managers.parameter_manager import ParameterManager
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils import utils
+from pymodaq_utils.config import Config
+
+from pymodaq_data.data import DataToExport
+
+from pymodaq_gui.managers.parameter_manager import ParameterManager
+from pymodaq_gui.utils import Dock
+
+from pymodaq.utils.data import DataActuator
 
 
 if TYPE_CHECKING:
@@ -490,7 +494,6 @@ if __name__ == '__main__':
     app = QtWidgets.QApplication(sys.argv)
     from qtpy.QtCore import QThread
     from pymodaq.utils.gui_utils import DockArea
-    from pyqtgraph.dockarea import Dock
     from pymodaq.control_modules.daq_viewer import DAQ_Viewer
     from pymodaq.control_modules.daq_move import DAQ_Move
 

pymodaq/utils/managers/overshoot_manager.py

@@ -2,11 +2,9 @@ from qtpy import QtWidgets
 import sys
 import os
 
-from pymodaq.utils.parameter import ioxml
-from pymodaq.utils.parameter import ParameterTree, Parameter
-from pyqtgraph.parametertree.Parameter import registerParameterType
-from pyqtgraph.parametertree.parameterTypes.basetypes import GroupParameter
-from pymodaq.utils.gui_utils import select_file
+from pymodaq_gui.parameter import ioxml, Parameter, ParameterTree
+from pymodaq_gui.parameter.pymodaq_ptypes import registerParameterType, GroupParameter
+from pymodaq_gui.utils import select_file
 
 # check if overshoot_configurations directory exists on the drive
 from pymodaq.utils.config import get_set_overshoot_path

pymodaq/utils/managers/preset_manager.py

@@ -1,23 +1,28 @@
-from pymodaq.extensions import get_models
-import pymodaq.utils.config
-from pymodaq.utils.logger import set_logger, get_module_name, get_module_name
-from pymodaq.utils.gui_utils.file_io import select_file
-from qtpy import QtWidgets
-import sys
 import os
-from pymodaq.utils.parameter import ParameterTree, Parameter
-from pymodaq.utils.parameter import ioxml
-from pymodaq.utils import daq_utils as utils
 from pathlib import Path
+import sys
+
+from qtpy import QtWidgets
+
+import pymodaq_utils.config as config_mod
+from pymodaq_utils.logger import set_logger, get_module_name
+
+from pymodaq_gui.utils.file_io import select_file
+from pymodaq_gui.parameter import ParameterTree, Parameter
+from pymodaq_gui.parameter import ioxml
+from pymodaq_gui.messenger import dialog as dialogbox
+from pymodaq.utils import config as config_mod_pymodaq
+from pymodaq.extensions import get_models
+
 import pymodaq.utils.managers.preset_manager_utils  # to register move and det types
 
 logger = set_logger(get_module_name(__file__))
 
 # check if preset_mode directory exists on the drive
-pid_path = pymodaq.utils.config.get_set_pid_path()
-preset_path = pymodaq.utils.config.get_set_preset_path()
-overshoot_path = pymodaq.utils.config.get_set_overshoot_path()
-layout_path = pymodaq.utils.config.get_set_layout_path()
+pid_path = config_mod_pymodaq.get_set_pid_path()
+preset_path = config_mod_pymodaq.get_set_preset_path()
+overshoot_path = config_mod_pymodaq.get_set_overshoot_path()
+layout_path = config_mod_pymodaq.get_set_layout_path()
 
 pid_models = [mod['name'] for mod in get_models()]
 
@@ -169,8 +174,25 @@ class PresetManager:
             # save managers parameters in a xml file
             # start = os.path.split(os.path.split(os.path.realpath(__file__))[0])[0]
             # start = os.path.join("..",'daq_scan')
-            ioxml.parameter_to_xml_file(
-                self.preset_params, os.path.join(path, self.preset_params.child('filename').value()))
+            filename_without_extension = self.preset_params.child('filename').value()
+
+            try:
+                ioxml.parameter_to_xml_file(self.preset_params,
+                                            os.path.join(path, filename_without_extension),
+                                            overwrite=False)
+            except FileExistsError as currenterror:
+                # logger.warning(str(currenterror)+"File " + filename_without_extension + ".xml exists")
+                logger.warning(f"{currenterror} File {filename_without_extension}.xml exists")
+                user_agreed = dialogbox(title='Overwrite confirmation',
+                                        message="File exist do you want to overwrite it ?")
+                if user_agreed:
+                    ioxml.parameter_to_xml_file(self.preset_params,
+                                                os.path.join(path, filename_without_extension))
+                    logger.warning(f"File {filename_without_extension}.xml overwriten at user request")
+                else:
+                    logger.warning(f"File {filename_without_extension}.xml wasn't saved at user request")
+                    # emit status signal to dashboard to write : did not save ?
+                pass
 
             if not self.pid_type:
                 # check if overshoot configuration and layout configuration with same name exists => delete them if yes

pymodaq/utils/managers/preset_manager_utils.py

@@ -1,19 +1,21 @@
 import random
 
-from pymodaq.utils.logger import set_logger, get_module_name
-from pymodaq.utils import daq_utils as utils
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils import utils
+
+from pymodaq_gui.parameter.pymodaq_ptypes import registerParameterType, GroupParameter
+
 from pymodaq.control_modules.move_utility_classes import params as daq_move_params
 from pymodaq.control_modules.viewer_utility_classes import params as daq_viewer_params
+from pymodaq.utils.daq_utils import get_plugins
 
-from pyqtgraph.parametertree.Parameter import registerParameterType
-from pyqtgraph.parametertree.parameterTypes.basetypes import GroupParameter
 logger = set_logger(get_module_name(__file__))
 
-DAQ_Move_Stage_type = utils.get_plugins('daq_move')
-DAQ_0DViewer_Det_types = utils.get_plugins('daq_0Dviewer')
-DAQ_1DViewer_Det_types = utils.get_plugins('daq_1Dviewer')
-DAQ_2DViewer_Det_types = utils.get_plugins('daq_2Dviewer')
-DAQ_NDViewer_Det_types = utils.get_plugins('daq_NDviewer')
+DAQ_Move_Stage_type = get_plugins('daq_move')
+DAQ_0DViewer_Det_types = get_plugins('daq_0Dviewer')
+DAQ_1DViewer_Det_types = get_plugins('daq_1Dviewer')
+DAQ_2DViewer_Det_types = get_plugins('daq_2Dviewer')
+DAQ_NDViewer_Det_types = get_plugins('daq_NDviewer')
 
 
 def iterative_show_pb(params):