pymodaq 3.6.13__py3-none-any.whl → 4.0.1__py3-none-any.whl

pymodaq/{daq_utils → utils}/db/db_logger/db_logger.py

@@ -1,21 +1,24 @@
 import logging
 import datetime
+from typing import List
 
-from pymodaq.daq_utils.config import Config
+from pymodaq.utils.logger import set_logger, get_module_name, get_module_name
+from pymodaq.utils.config import Config
 from qtpy import QtCore
 from contextlib import contextmanager
 from sqlalchemy import create_engine
 from sqlalchemy.orm import sessionmaker
 from sqlalchemy_utils import database_exists, create_database
-from pymodaq.daq_utils.db.db_logger.db_logger_models import Base, Data0D, Data1D, Data2D, LogInfo, Detector, Configuration
-from pymodaq.daq_utils import daq_utils as utils
-from pymodaq.daq_utils.gui_utils import dashboard_submodules_params
-from pymodaq.daq_utils.messenger import messagebox
-from pymodaq.daq_utils.abstract.logger import AbstractLogger
+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 pyqtgraph.parametertree import Parameter, ParameterTree
 
 
-logger = utils.set_logger(utils.get_module_name(__file__))
+logger = set_logger(get_module_name(__file__))
 config = Config()
 
 
@@ -112,7 +115,7 @@ class DbLogger:
         if self.engine is not None:
             Base.metadata.create_all(self.engine)
 
-    def get_detectors(self, session):
+    def get_detectors(self, session) -> List[str]:
         """Returns the list of detectors name
 
         Parameters
@@ -121,25 +124,51 @@ class DbLogger:
 
         Returns
         -------
-        list of str
+        the list of all created detectors
         """
-        return [res[0] for res in session.query(Detector.name)]
+        return [res[0] for res in session.query(ControlModule.name)]
+
+    def get_actuators(self, session) -> List[str]:
+        """Returns the list of actuators name
+
+        Parameters
+        ----------
+        session: (Session) SQLAlchemy session instance for db transactions
+
+        Returns
+        -------
+        the list of all created actuators
+        """
+        return [res[0] for res in session.query(ControlModule.name)]
 
     def add_detectors(self, detectors):
         """
         add detectors in the detectors table
         Parameters
         ----------
-        session: (Session) SQLAlchemy session instance for db transactions
         detectors: (list) list of dict with keys: name and settings_xml
         """
-        if not isinstance(detectors, list):
-            detectors = [detectors]
+        self.add_control_modules(detectors, 'DAQ_Viewer')
+
+    def add_actuators(self, actuators):
+        """
+        add actuators in the actuators table
+        Parameters
+        ----------
+        actuators: list
+            list of dict with keys: name and settings_xml
+        """
+        self.add_control_modules(actuators, 'DAQ_Move')
+
+    def add_control_modules(self, modules, module_type='DAQ_Viewer'):
+        if not isinstance(modules, list):
+            modules = [modules]
         with self.session_scope() as session:
-            existing_detectors = [d.name for d in session.query(Detector)]
-            for det in detectors:
-                if det['name'] not in existing_detectors:
-                    session.add(Detector(name=det['name'], settings_xml=det['xml_settings']))
+            existing_modules = [d.name for d in session.query(ControlModule)]
+            for mod in modules:
+                if mod['name'] not in existing_modules:
+                    session.add(ControlModule(name=mod['name'], module_type=module_type,
+                                              settings_xml=mod['xml_settings']))
 
     def add_config(self, config_settings):
         with self.session_scope() as session:
@@ -149,37 +178,44 @@ class DbLogger:
         with self.session_scope() as session:
             session.add(LogInfo(log))
 
-    def add_datas(self, datas):
+    def add_data(self, data):
         with self.session_scope() as session:
-            time_stamp = datas['acq_time_s']
-            detector_name = datas['name']
-            if session.query(Detector).filter_by(name=detector_name).count() == 0:
-                # security detector adding in case it hasn't been done previously (and properly)
-                self.add_detectors(session, dict(name=detector_name))
-
-            det_id = session.query(Detector).filter_by(name=detector_name).one().id  # detector names should/are unique
-
-            if 'data0D' in datas:
-                for channel in datas['data0D']:
-                    session.add(Data0D(timestamp=time_stamp, detector_id=det_id,
-                                       channel=f"{datas['data0D'][channel]['name']}:{channel}",
-                                       value=datas['data0D'][channel]['data']))
-
-            if 'data1D' in datas:
-                for channel in datas['data1D']:
-                    session.add(Data1D(timestamp=time_stamp, detector_id=det_id,
-                                       channel=f"{datas['data1D'][channel]['name']}:{channel}",
-                                       value=datas['data1D'][channel]['data'].tolist()))
-
-            if 'data2D' in datas and self.save2D:
-                for channel in datas['data2D']:
-                    session.add(Data2D(timestamp=time_stamp, detector_id=det_id,
-                                       channel=f"{datas['data2D'][channel]['name']}:{channel}",
-                                       value=datas['data2D'][channel]['data'].tolist()))
+            time_stamp = data['acq_time_s']
+            module_name = data['name']
+
+            if session.query(ControlModule).filter_by(name=module_name).count() == 0:
+                self.add_control_modules(session, dict(name=module_name), data['control_module'])
+
+            module_id = session.query(ControlModule).filter_by(name=module_name).one().id  # detector/actuator names should/are unique
+
+            if 'data0D' in data:
+                for channel in data['data0D']:
+                    d = data['data0D'][channel]['data']
+                    if hasattr(d, '__len__'):
+                        d = float(d[0])
+                    if data['control_module'] == 'DAQ_Move':
+                        channel = f"{data['data0D'][channel]['name']}"
+                    else:
+                        channel = f"{data['data0D'][channel]['name']}:{channel}"
+                    session.add(Data0D(timestamp=time_stamp, control_module_id=module_id, channel=channel, value=d))
+
+            if 'data1D' in data:
+                for channel in data['data1D']:
+                    session.add(Data1D(timestamp=time_stamp, control_module_id=module_id,
+                                       channel=f"{data['data1D'][channel]['name']}:{channel}",
+                                       value=data['data1D'][channel]['data'].tolist()))
+
+            if 'data2D' in data and self.save2D:
+                for channel in data['data2D']:
+                    session.add(Data2D(timestamp=time_stamp, control_module_id=module_id,
+                                       channel=f"{data['data2D'][channel]['name']}:{channel}",
+                                       value=data['data2D'][channel]['data'].tolist()))
 
             # not yet dataND as db should not know where to save these datas
 
 
+
+
 class DbLoggerGUI(DbLogger, QtCore.QObject):
     params = [
         {'title': 'Database:', 'name': 'database_type', 'type': 'list', 'value': 'PostgreSQL',
@@ -276,10 +312,13 @@ class DataBaseLogger(AbstractLogger):
     def add_detector(self, det_name, settings):
         self.dblogger.add_detectors([dict(name=det_name, xml_settings=settings)])
 
-    def add_datas(self, datas):
-        self.dblogger.add_datas(datas)
-        self.settings.child(('N_saved')).setValue(
-            self.settings.child(('N_saved')).value() + 1)
+    def add_actuator(self, act_name, settings):
+        self.dblogger.add_actuators([dict(name=act_name, xml_settings=settings)])
+
+    def add_data(self, data):
+        self.dblogger.add_data(data)
+        self.settings.child('N_saved').setValue(
+            self.settings.child('N_saved').value() + 1)
 
     def stop_logger(self):
         pass

pymodaq/{daq_utils → utils}/db/db_logger/db_logger_models.py

@@ -15,18 +15,39 @@ class Configuration(Base):
     def __repr__(self):
         return f"<Config(date='{datetime.datetime.fromtimestamp(self.timestamp).isoformat()}', settings_xml='{self.settings_xml[0:20]}')>"
 
-
-class Detector(Base):
-    __tablename__ = 'detectors'
+# class Actuator(Base):
+#     __tablename__ = 'actuators'
+#     id = Column(Integer, primary_key=True)
+#     name = Column(String(128))
+#     settings_xml = Column(String)
+#     datas0D = relationship("Data0D", backref='actuators')
+#
+#
+# class Detector(Base):
+#     __tablename__ = 'detectors'
+#     id = Column(Integer, primary_key=True)
+#     name = Column(String(128))
+#     settings_xml = Column(String)
+#     datas0D = relationship("Data0D", backref='detectors')
+#     datas1D = relationship("Data1D", backref='detectors')
+#     datas2D = relationship("Data2D", backref='detectors')
+#
+#     def __repr__(self):
+#         return f"<Detector(name='{self.name}', settings_xml='{self.settings_xml[0:20]}')>"
+
+
+class ControlModule(Base):
+    __tablename__ = 'control_modules'
     id = Column(Integer, primary_key=True)
     name = Column(String(128))
+    module_type = Column(String(128))
     settings_xml = Column(String)
-    datas0D = relationship("Data0D", backref='detectors')
-    datas1D = relationship("Data1D", backref='detectors')
-    datas2D = relationship("Data2D", backref='detectors')
+    datas0D = relationship("Data0D", backref='control_modules')
+    datas1D = relationship("Data1D", backref='control_modules')
+    datas2D = relationship("Data2D", backref='control_modules')
 
     def __repr__(self):
-        return f"<Detector(name='{self.name}', settings_xml='{self.settings_xml[0:20]}')>"
+        return f"<Control Module {self.type} (name='{self.name}', settings_xml='{self.settings_xml[0:20]}')>"
 
 
 class LogInfo(Base):
@@ -43,7 +64,7 @@ class Data0D(Base):
 
     id = Column(Integer, primary_key=True)
     timestamp = Column(Integer, nullable=False, index=True)
-    detector_id = Column(Integer, ForeignKey('detectors.id'), index=True)
+    control_module_id = Column(Integer, ForeignKey('control_modules.id'), index=True)
     channel = Column(String(128))
     value = Column(Float)
 
@@ -56,7 +77,7 @@ class Data1D(Base):
 
     id = Column(Integer, primary_key=True)
     timestamp = Column(Integer, nullable=False, index=True)
-    detector_id = Column(Integer, ForeignKey('detectors.id'), index=True)
+    control_module_id = Column(Integer, ForeignKey('control_modules.id'), index=True)
     channel = Column(String(128))
     value = Column(Array(Float, dimensions=1))
 
@@ -69,7 +90,7 @@ class Data2D(Base):
 
     id = Column(Integer, primary_key=True)
     timestamp = Column(Integer, nullable=False, index=True)
-    detector_id = Column(Integer, ForeignKey('detectors.id'), index=True)
+    control_module_id = Column(Integer, ForeignKey('control_modules.id'), index=True)
     channel = Column(String(128))
     value = Column(Array(Float, dimensions=2))
 

pymodaq/{daq_utils → utils}/enums.py

@@ -1,10 +1,8 @@
-# -*- coding: utf-8 -*-
-"""
-Created the 11/01/2023
-
-@author: Sebastien Weber
-"""
 from enum import Enum
+from pymodaq.utils.daq_utils import find_index
+from pymodaq.utils.math_utils import my_moment
+import numpy as np
+from scipy.optimize import curve_fit
 from typing import List, Union
 
 
@@ -31,11 +29,15 @@ class BaseEnum(Enum):
 
 def enum_checker(enum: BaseEnum, item: Union[BaseEnum, str]):
     """Check if the item parameter is a valid enum or at least one valid string name of the enum
+
     If a string, transforms it to a valid enum (case not important)
+
     Parameters
     ----------
     enum: BaseEnum class or one of its derivated class
+
     item: str or BaseEnum instance
+
     Returns
     -------
     BaseEnum class or one of its derivated class
@@ -52,4 +54,7 @@ def enum_checker(enum: BaseEnum, item: Union[BaseEnum, str]):
         else:
             raise ValueError(f'{item} is an invalid {enum}. Should be a {enum} enum or '
                              f'a string in {enum.names()}')
-    return item
+    return item
+
+
+

pymodaq/utils/exceptions.py

@@ -0,0 +1,37 @@
+class DAQ_ScanException(Exception):
+    """Raised when an error occur within the DAQScan"""
+    pass
+
+
+
+
+
+class DetectorError(Exception):
+    pass
+
+
+class ActuatorError(Exception):
+    pass
+
+
+class ViewerError(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/factory.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 04/11/2022
+
+@author: Sebastien Weber
+"""
+from typing import Callable, Union
+from abc import ABCMeta, abstractmethod
+
+from pymodaq.utils.logger import set_logger, get_module_name
+
+logger = set_logger(get_module_name(__file__))
+
+
+class BuilderBase(ABCMeta):
+    """Abstract class defining an object/service builder with a callable interface accepting some arguments
+
+    See https://realpython.com/factory-method-python/ for some details
+
+    See Also
+    --------
+    pymodaq.post_treatment.process_1d_to_scalar
+    """
+    @abstractmethod
+    def __call__(self, *args, **kwargs):
+        pass
+
+
+class ObjectFactory(metaclass=ABCMeta):
+    """Generic ObjectFactory with a decorator register to add object builders to the factory with a unique key
+    identifier
+
+    See https://realpython.com/factory-method-python/ for some details
+
+    Examples
+    --------
+    @ObjectFactory.register('custom')
+    def my_custom_builder():
+        pass
+
+    See Also
+    --------
+    pymodaq.post_treatment.process_1d_to_scalar.Data1DProcessorFactory
+    """
+    _builders = {}
+
+    @classmethod
+    def register(cls, key: str) -> Callable:
+        def inner_wrapper(wrapped_class: Union[BuilderBase, Callable]) -> Callable:
+            if cls.__name__ not in cls._builders:
+                cls._builders[cls.__name__] = {}
+            if key not in cls._builders[cls.__name__]:
+                cls._builders[cls.__name__][key] = wrapped_class
+            else:
+                logger.warning(f'The {cls.__name__}/{key} builder is already registered. Replacing it')
+            return wrapped_class
+        return inner_wrapper
+
+    @property
+    def builders(self):
+        return self._builders
+
+    def keys_function(self, do_sort=True):
+        if do_sort:
+            return self.keys
+        else:
+            return list(self.builders[self.__class__.__name__].keys())
+
+    @property
+    def keys(self):
+        return sorted(list(self.builders[self.__class__.__name__].keys()))
+
+    @classmethod
+    def create(cls, key, **kwargs):
+        builder = cls._builders[cls.__name__].get(key)
+        if not builder:
+            raise ValueError(key)
+        return builder(**kwargs)
+
+    @classmethod
+    def get_class(cls, key):
+        return cls._builders[cls.__name__].get(key)

pymodaq/{daq_utils → utils}/gui_utils/__init__.py

@@ -3,8 +3,8 @@ 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.lcd import LCD
 from .widgets.push import PushButtonIcon, EditPush, EditPushRel, EditPushInfo
 from .widgets.qled import QLED
 from .widgets.spinbox import QSpinBox_ro
 
+from .utils import get_splash_sc

pymodaq/utils/gui_utils/custom_app.py

@@ -0,0 +1,129 @@
+from qtpy.QtCore import QObject, QLocale
+from pymodaq.utils.gui_utils.dock import DockArea
+from pymodaq.utils.managers.action_manager import ActionManager
+from pymodaq.utils.managers.parameter_manager import ParameterManager
+from pyqtgraph.dockarea import DockArea
+from qtpy import QtCore, QtWidgets
+from typing import Union
+
+
+class CustomApp(QObject, ActionManager, ParameterManager):
+    """Base Class to ease the implementation of User Interfaces
+
+    Inherits the MixIns ActionManager and ParameterManager classes. You have to subclass some methods and make
+    concrete implementation of a given number of methods:
+
+    * setup_actions: mandatory, see :class:`pymodaq.utils.managers.action_manager.ActionManager`
+    * value_changed: non mandatory, see :class:`pymodaq.utils.managers.parameter_manager.ParameterManager`
+    * child_added: non mandatory, see :class:`pymodaq.utils.managers.parameter_manager.ParameterManager`
+    * param_deleted: non mandatory, see :class:`pymodaq.utils.managers.parameter_manager.ParameterManager`
+    * setup_docks: mandatory
+    * setup_menu: non mandatory
+    * connect_things: mandatory
+
+    Parameters
+    ----------
+    parent: DockArea or QtWidget
+    dashboard: DashBoard, optional
+
+    See Also
+    --------
+    :class:`pymodaq.utils.managers.action_manager.ActionManager`,
+    :class:`pymodaq.utils.managers.parameter_manager.ParameterManager`,
+    :class:`pymodaq.utils.managers.modules_manager.ModulesManager`,
+    :class:`pymodaq.dashboard.DashBoard`
+    """
+
+    log_signal = QtCore.Signal(str)
+    params = []
+
+    def __init__(self, parent: Union[DockArea, QtWidgets.QWidget], dashboard=None):
+        QObject.__init__(self)
+        ActionManager.__init__(self)
+        ParameterManager.__init__(self)
+        QLocale.setDefault(QLocale(QLocale.English, QLocale.UnitedStates))
+
+        if not isinstance(parent, DockArea):
+            if not isinstance(parent, QtWidgets.QWidget):
+                raise Exception('no valid parent container, expected a DockArea or a least a QWidget')
+
+        self.parent = parent
+        if isinstance(parent, DockArea):
+            self.dockarea: DockArea = parent
+            self.mainwindow: QtWidgets.QMainWindow = parent.parent()
+        else:
+            self.dockarea: DockArea = None
+            self.mainwindow: QtWidgets.QMainWindow = None
+        self.dashboard = dashboard
+
+        self.docks = dict([])
+        self.statusbar = None
+        self._toolbar = QtWidgets.QToolBar()
+
+        if self.mainwindow is not None:
+            self.mainwindow.addToolBar(self._toolbar)
+            self.statusbar = self.mainwindow.statusBar()
+
+        self.set_toolbar(self._toolbar)
+
+    def setup_ui(self):
+        self.setup_docks()
+
+        self.setup_actions()  # see ActionManager MixIn class
+
+        self.setup_menu()
+
+        self.connect_things()
+
+    def setup_docks(self):
+        """Mandatory method to be subclassed to setup the docks layout
+
+        Examples
+        --------
+        >>>self.docks['ADock'] = gutils.Dock('ADock name')
+        >>>self.dockarea.addDock(self.docks['ADock'])
+        >>>self.docks['AnotherDock'] = gutils.Dock('AnotherDock name')
+        >>>self.dockarea.addDock(self.docks['AnotherDock'''], 'bottom', self.docks['ADock'])
+
+        See Also
+        --------
+        pyqtgraph.dockarea.Dock
+        """
+        raise NotImplementedError
+
+    def setup_menu(self):
+        """Non mandatory method to be subclassed in order to create a menubar
+
+        create menu for actions contained into the self._actions, for instance:
+
+        Examples
+        --------
+        >>>file_menu = self._menubar.addMenu('File')
+        >>>self.affect_to('load', file_menu)
+        >>>self.affect_to('save', file_menu)
+
+        >>>file_menu.addSeparator()
+        >>>self.affect_to('quit', file_menu)
+
+        See Also
+        --------
+        pymodaq.utils.managers.action_manager.ActionManager
+        """
+        pass
+
+    def connect_things(self):
+        """Connect actions and/or other widgets signal to methods"""
+        raise NotImplementedError
+
+    @property
+    def modules_manager(self):
+        """useful tool to interact with DAQ_Moves and DAQ_Viewers
+
+        Will be available if a DashBoard has been set
+
+        Returns
+        -------
+        ModulesManager
+        """
+        if self.dashboard is not None:
+            return self.dashboard.modules_manager

pymodaq/utils/gui_utils/file_io.py

@@ -0,0 +1,66 @@
+from pathlib import Path
+
+from pymodaq.utils.config import Config
+from qtpy import QtWidgets
+
+config = Config()
+
+
+def select_file(start_path=config('data_saving', 'h5file', 'save_path'), save=True, ext=None, filter=None,
+                force_save_extension=False):
+    """Opens a selection file popup for loading or saving a file
+
+    Parameters
+    ----------
+    start_path: str or Path
+        The strating point in the file/folder system to open the popup from
+    save: bool
+        if True, ask you to enter a filename (with or without extension)
+    ext: str
+        the extension string, e.g. xml, h5, png ...
+    filter: list of string
+        list of possible extensions, mostly valid for loading
+    force_save_extension: bool
+        if True force the extension of the saved file to be set to ext
+
+    Returns
+    -------
+    Path: the Path object of the file to save or load
+    """
+    if ext is None:
+        ext = '.h5'
+
+    if filter is None:
+        if not save:
+            if not isinstance(ext, list):
+                ext = [ext]
+            filter = "Data files ("
+            for ext_tmp in ext:
+                filter += '*.' + ext_tmp + " "
+            filter += ")"
+    
+    if start_path is not None:
+        if not isinstance(start_path, str):
+            start_path = str(start_path)
+    if save:
+        fname = QtWidgets.QFileDialog.getSaveFileName(None, 'Enter a file name', start_path,
+                                                      filter)
+    else:
+        fname = QtWidgets.QFileDialog.getOpenFileName(None, 'Select a file name', start_path, filter)
+
+    fname = fname[0]
+    if fname != '':  # execute if the user didn't cancel the file selection
+        fname = Path(fname)
+        if save and force_save_extension:
+            parent = fname.parent
+            filename = fname.stem
+            fname = parent.joinpath(filename + "." + ext)  # forcing the right extension on the filename
+    return fname  # fname is a Path object
+
+
+if __name__ == '__main__':
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    file = select_file(save=True, filter="Images (*.png *.xpm *.jpg);;Text files (*.txt);;XML files (*.xml)")
+    print(file)
+    sys.exit(app.exec_())

pymodaq/{daq_utils → utils}/gui_utils/layout.py

@@ -1,7 +1,7 @@
 import pickle
 
-from pymodaq.daq_utils import config as config_mod
-from pymodaq.daq_utils.gui_utils.file_io import select_file
+from pymodaq.utils import config as config_mod
+from pymodaq.utils.gui_utils.file_io import select_file
 
 
 def load_layout_state(dockarea, file=None):