pymodaq 5.1.6__py3-none-any.whl

pymodaq/utils/config.py

@@ -0,0 +1,53 @@
+
+from pathlib import Path
+
+try:
+    from pymodaq_gui.config_saver_loader import get_set_roi_path
+except ModuleNotFoundError:
+    from pymodaq_gui.config import get_set_roi_path
+
+from pymodaq_utils.config import (BaseConfig, ConfigError, get_set_config_dir,
+                                  USER, CONFIG_BASE_PATH, get_set_local_dir)
+
+
+def get_set_preset_path():
+    """ creates and return the config folder path for managers files
+    """
+    return get_set_config_dir('preset_configs')
+
+
+def get_set_batch_path():
+    """ creates and return the config folder path for managers files
+    """
+    return get_set_config_dir('batch_configs')
+
+
+def get_set_pid_path():
+    """ creates and return the config folder path for PID files
+    """
+    return get_set_config_dir('pid_configs')
+
+
+def get_set_layout_path():
+    """ creates and return the config folder path for layout files
+    """
+    return get_set_config_dir('layout_configs')
+
+
+def get_set_remote_path():
+    """ creates and return the config folder path for remote (shortcuts or joystick) files
+    """
+    return get_set_config_dir('remote_configs')
+
+
+def get_set_overshoot_path():
+    """ creates and return the config folder path for overshoot files
+    """
+    return get_set_config_dir('overshoot_configs')
+
+
+class Config(BaseConfig):
+    """Main class to deal with configuration values for this plugin"""
+    config_template_path = Path(__file__).parent.parent.joinpath('resources/config_template.toml')
+    config_name = f"config_pymodaq"
+

pymodaq/utils/conftests.py

@@ -0,0 +1,5 @@
+import pytest
+
+qtbotskip = True
+
+main_modules_skip = True

pymodaq/utils/daq_utils.py

@@ -0,0 +1,158 @@
+
+import importlib
+from packaging import version as version_mod
+import pkgutil
+import platform
+from pathlib import Path
+
+from pymodaq_utils.config import Config
+from pymodaq_utils.utils import get_entrypoints, ThreadCommand, getLineInfo, find_keys_from_val, is_64bits, timer  # for backcompat
+from pymodaq_utils.logger import set_logger, get_module_name  # for backcompat
+
+from pymodaq.utils.data import DataFromPlugins   # for backcompat
+
+from pymodaq.utils.config import get_set_preset_path
+
+if version_mod.parse(platform.python_version()) >= version_mod.parse('3.9'):
+    # from version 3.9 the cache decorator is available
+    from functools import cache
+else:
+    from functools import lru_cache as cache
+
+
+logger = set_logger(get_module_name(__file__))
+
+config = Config()
+
+
+def copy_preset():                          # pragma: no cover
+    path = get_set_preset_path().joinpath('preset_default.xml')
+    if not path.exists():  # copy the preset_default from pymodaq folder and create one in pymodad's local folder
+        with open(str(Path(__file__).parent.parent.joinpath('resources/preset_default.xml')), 'r') as file:
+            path.write_text(file.read())
+
+
+@cache
+def get_instrument_plugins():  # pragma: no cover
+    """
+    Get plugins names as a list
+    Parameters
+    ----------
+    plugin_type: (str) plugin type either 'daq_0Dviewer', 'daq_1Dviewer', 'daq_2Dviewer', 'daq_NDviewer' or 'daq_move'
+    module: (module) parent module of the plugins
+
+    Returns
+    -------
+
+    """
+    plugins_import = []
+    discovered_plugins = []
+    discovered_plugins_all = list(get_entrypoints(group='pymodaq.plugins'))  # old naming of the instrument plugins
+    discovered_plugins_all.extend(list(get_entrypoints(group='pymodaq.instruments')))  # new naming convention
+    for entry in discovered_plugins_all:
+        if entry.name not in [ent.name for ent in discovered_plugins]:
+            discovered_plugins.append(entry)
+    discovered_plugins = list(set(discovered_plugins))
+    logger.debug(f'Found {len(discovered_plugins)} installed plugins, trying to import them')
+    viewer_types = ['0D', '1D', '2D', 'ND']
+    plugin_list = []
+    for entrypoint in discovered_plugins:
+        #print(f'Looking for valid instrument plugins in package: {module.value}')
+
+        try:
+            try:
+                movemodule = importlib.import_module(f'{entrypoint.value}.daq_move_plugins', entrypoint.value)
+                plugin_list.extend([{'name': mod[len('daq_move') + 1:],
+                                     'module': movemodule,
+                                     'parent_module': importlib.import_module(entrypoint.value),
+                                     'type': 'daq_move'}
+                                    for mod in [mod[1] for mod in pkgutil.iter_modules([str(movemodule.path.parent)])]
+                                    if 'daq_move' in mod])
+                if len(plugin_list) > 0:
+                    logger.debug(f"Found Move Instrument:"
+                                f" {plugin_list[-1]['module'].__name__}/{plugin_list[-1]['name']}")
+            except ModuleNotFoundError:
+                pass
+
+            viewer_modules = {}
+            for vtype in viewer_types:
+                try:
+                    viewer_modules[vtype] = importlib.import_module(f'{entrypoint.value}.daq_viewer_plugins.plugins_{vtype}',
+                                                    entrypoint.value)
+                    plugin_list.extend([{'name': mod[len(f'daq_{vtype}viewer') + 1:],
+                                     'module': viewer_modules[vtype],
+                                     'parent_module': importlib.import_module(entrypoint.value),
+                                     'type': f'daq_{vtype}viewer'}
+                                    for mod in [mod[1] for mod in pkgutil.iter_modules([str(viewer_modules[vtype].path.parent)])]
+                                    if f'daq_{vtype}viewer' in mod])
+                    if len(plugin_list) > 0:
+                        logger.debug(f"Found Viewer Instrument: "
+                                    f"{plugin_list[-1]['module'].__name__}/{plugin_list[-1]['name']}")
+                except ModuleNotFoundError:
+                    pass
+
+        except Exception as e:  # pragma: no cover
+            logger.debug(str(e))
+
+    for mod in plugin_list:
+        try:
+            plugin_type = mod['type']
+            if plugin_type == 'daq_move':
+                submodule = mod['module']
+                importlib.import_module(f'{submodule.__package__}.daq_move_{mod["name"]}')
+            else:
+                submodule = mod['module']
+                importlib.import_module(f'{submodule.__package__}.daq_{plugin_type[4:6]}viewer_{mod["name"]}')
+            plugins_import.append(mod)
+            logger.info(f"{mod['module'].__name__}/{mod['name']} available")
+        except Exception as e:  # pragma: no cover
+            """If an error is generated at the import, then exclude this plugin"""
+            logger.debug(f'Impossible to import Instrument plugin {mod["name"]}'
+                         f' from module: {mod["parent_module"].__package__}')
+
+
+    # add utility plugin for PID
+    try:
+        pidmodule = importlib.import_module('pymodaq.extensions.pid')
+        mod = [{'name': 'PID',
+               'module': pidmodule,
+               'parent_module': pidmodule,
+               'type': 'daq_move'}]
+        importlib.import_module(f'{pidmodule.__package__}.daq_move_PID')
+        plugins_import.extend(mod)
+
+    except Exception as e:
+        logger.debug(f'Impossible to import PID utility plugin: {str(e)}')
+
+    # add utility plugin for DataMixer
+    try:
+        data_mixer_module = importlib.import_module('pymodaq.extensions.data_mixer')
+        mod = [{'name': 'DataMixer',
+                'module': data_mixer_module,
+                'parent_module': data_mixer_module,
+                'type': 'daq_0Dviewer'}]
+        importlib.import_module(f'{data_mixer_module.__package__}.daq_0Dviewer_DataMixer')
+        plugins_import.extend(mod)
+
+    except Exception as e:
+        logger.debug(f'Impossible to import the DataMixer utility plugin: {str(e)}')
+
+
+    plugins_import.sort(key=lambda mod: mod['name'])
+    return plugins_import
+
+
+def get_plugins(plugin_type='daq_0Dviewer'):  # pragma: no cover
+    """
+    Get plugins names as a list
+    Parameters
+    ----------
+    plugin_type: (str) plugin type either 'daq_0Dviewer', 'daq_1Dviewer', 'daq_2Dviewer', 'daq_NDviewer' or 'daq_move'
+    module: (module) parent module of the plugins
+
+    Returns
+    -------
+
+    """
+    return [plug for plug in get_instrument_plugins() if plug['type'] == plugin_type]
+

pymodaq/utils/data.py

@@ -0,0 +1,128 @@
+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, 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"""
+    def __init__(self, *args, **kwargs):
+        if len(args) == 0 and 'name' not in kwargs:
+            args = ['actuator']
+        if 'data' not in kwargs:
+            kwargs['data'] = [np.array([0.])]
+        elif isinstance(kwargs['data'], numbers.Number):  # useful formatting
+            kwargs['data'] = [np.array([kwargs['data']])]
+        super().__init__(*args, **kwargs)
+
+    def __repr__(self):
+        if self.dim.name == 'Data0D':
+            return f'<{self.__class__.__name__} ({self.data[0][0]} {self.units})>'
+        else:
+            return f'<{self.__class__.__name__} ({self.shape} {self.units})>'
+
+    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
+
+        else:
+            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
+
+    It introduces by default to extra attributes, do_plot and do_save. Their presence can be checked in the
+    extra_attributes list.
+
+    Parameters
+    ----------
+    do_plot: bool
+        If True the underlying data will be plotted in the DAQViewer
+    do_save: bool
+        If True the underlying data will be saved
+
+    Attributes
+    ----------
+    do_plot: bool
+        If True the underlying data will be plotted in the DAQViewer
+    do_save: bool
+        If True the underlying data will be saved
+    """
+    def __init__(self, *args, **kwargs):
+
+        ##### for backcompatibility
+        if 'plot' in kwargs:
+            deprecation_msg("'plot' should not be used anymore as extra_attribute, "
+                            "please use 'do_plot'")
+            do_plot = kwargs.pop('plot')
+            kwargs['do_plot'] = do_plot
+
+        if 'save' in kwargs:
+            deprecation_msg("'save' should not be used anymore as extra_attribute, "
+                            "please use 'do_save'")
+            do_save = kwargs.pop('save')
+            kwargs['do_save'] = do_save
+        #######
+
+        if 'do_plot' not in kwargs:
+            kwargs['do_plot'] = True
+        if 'do_save' not in kwargs:
+            kwargs['do_save'] = True
+        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
+
+    Attributes
+    ----------
+    mode: str
+        Adds an attribute called mode holding a string describing the type of change:
+        relative or absolute
+
+    Parameters
+    ---------
+    mode: str
+        either 'rel' or 'abs' for a relative or absolute change of the actuator's values
+    """
+    mode: str
+
+    def __init__(self, *args, mode='rel', **kwargs):
+        if mode not in ['rel', 'abs']:
+            user_warning('Incorrect mode for the actuators, '
+                         'switching to default relative mode: rel')
+            mode = 'rel'
+        kwargs.update({'mode': mode})
+        super().__init__(*args, **kwargs)
+
+    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/exceptions.py

@@ -0,0 +1,38 @@
+class DAQ_ScanException(Exception):
+    """Raised when an error occur within the DAQScan"""
+    pass
+
+
+class DetectorError(Exception):
+    pass
+
+
+class ActuatorError(Exception):
+    pass
+
+
+class PIDError(Exception):
+    pass
+
+
+class MasterSlaveError(Exception):
+    pass
+
+
+class ExpectedError(Exception):
+    """Raised in the tests made for pymodaq plugins"""
+    pass
+
+
+class Expected_1(ExpectedError):
+    """Expected error 1 for pymodaq tests"""
+    pass
+
+
+class Expected_2(ExpectedError):
+    """Expected error 2 for pymodaq tests"""
+    pass
+
+
+class Expected_3(ExpectedError):
+    """Expected error 3 for pymodaq tests"""

pymodaq/utils/gui_utils/__init__.py

@@ -0,0 +1,10 @@
+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,75 @@
+from pathlib import Path
+
+from qtpy.QtWidgets import QMessageBox, QMainWindow
+
+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) -> \
+        (DashBoard, CustomExt, 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 = QMainWindow()
+    area = DockArea()
+    win.setCentralWidget(area)
+    win.resize(1000, 500)
+    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():
+        dashboard.set_preset_mode(file)
+
+        if extension_name:
+            if extension_name == 'DAQScan':
+                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()
+            elif extension_name == 'AdaptiveScan':
+                extension = dashboard.load_adaptive()
+            elif extension_name == 'Data Mixer':
+                extension = dashboard.load_datamixer()
+            else:
+                extension = dashboard.load_extension_from_name(extension_name)
+        else:
+            extension = None
+
+    else:
+        msgBox = 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(QMessageBox.StandardButton.Ok)
+        ret = msgBox.exec()
+    return dashboard, extension, win

pymodaq/utils/gui_utils/utils.py

@@ -0,0 +1,18 @@
+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')
+
+
+

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

@@ -0,0 +1,2 @@
+
+