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

pymodaq/extensions/pid/pid_controller.py

@@ -1,5 +1,7 @@
 import time
 from functools import partial  # needed for the button to sync setpoint with currpoint
+from typing import Dict, List, TYPE_CHECKING
+
 import numpy as np
 
 from qtpy import QtGui, QtWidgets
@@ -9,13 +11,14 @@ from simple_pid import PID
 
 from pymodaq_utils.logger import set_logger, get_module_name
 from pymodaq_utils.utils import ThreadCommand, find_dict_in_list_from_key_val
+from pymodaq.utils.exceptions import DetectorError, ActuatorError, PIDError
 
 from pymodaq_gui.parameter import utils as putils
 from pymodaq_gui.parameter import Parameter, ParameterTree
 from pymodaq_gui.plotting.data_viewers.viewer0D import Viewer0D
 from pymodaq_gui.utils.widgets import QLED, LabelWithFont, SpinBox
 from pymodaq_gui.utils.dock import DockArea, Dock
-from pymodaq_gui.utils.custom_app import CustomApp
+
 
 from pymodaq_data.data import DataToExport, DataCalculated, DataRaw
 from pymodaq_utils.config import Config
@@ -23,6 +26,11 @@ from pymodaq_utils.config import Config
 from pymodaq.utils.managers.modules_manager import ModulesManager
 from pymodaq.extensions.pid.utils import get_models
 from pymodaq.utils.data import DataActuator, DataToActuators
+from pymodaq.extensions.pid.actuator_controller import PIDController
+from pymodaq.extensions.utils import CustomExt
+
+if TYPE_CHECKING:
+    from pymodaq.control_modules.daq_move import DAQ_Move
 
 
 config = Config()
@@ -38,7 +46,7 @@ def convert_output_limits(lim_min=-10., min_status=False, lim_max=10., max_statu
     return output
 
 
-class DAQ_PID(CustomApp):
+class DAQ_PID(CustomExt):
     """
     """
     command_pid = Signal(ThreadCommand)
@@ -170,7 +178,7 @@ class DAQ_PID(CustomApp):
         self.set_action_enabled('run', enable)
         self.set_action_enabled('pause', enable)
 
-    def setup_menu(self):
+    def setup_menu(self, menubar: QtWidgets.QMenuBar = None):
         '''
         to be subclassed
         create menu for actions contained into the self.actions_manager, for instance:
@@ -241,6 +249,7 @@ class DAQ_PID(CustomApp):
         logger.debug('connecting actions and other')
         self.connect_action('quit', self.quit_fun, )
         self.connect_action('ini_model', self.ini_model)
+        self.connect_action('create_setp_actuators', self.create_setp_actuators)
         self.connect_action('ini_pid', self.ini_PID)
         self.connect_action('run', self.run_PID)
         self.connect_action('pause', self.pause_PID)
@@ -252,12 +261,21 @@ class DAQ_PID(CustomApp):
         self.add_widget('model_label', QtWidgets.QLabel, 'Init Model:')
         self.add_action('ini_model', 'Init Model', 'ini', tip='Initialize the selected model: algo/data conversion')
         self.add_widget('model_led', QLED, toolbar=self.toolbar)
+
+        self.add_action('create_setp_actuators', 'Create SetPoint Actuators', 'Add_Step',
+                        tip='Create a DAQ_Move Control Module for each SetPoint allowing to'
+                            'control them from the DashBoard, therefore within other extensions')
+
         self.add_widget('model_label', QtWidgets.QLabel, 'Init PID Runner:')
-        self.add_action('ini_pid', 'Init the PID loop', 'ini', tip='Init the PID thread', checkable=True)
+        self.add_action('ini_pid', 'Init the PID loop', 'ini', tip='Init the PID thread',
+                        checkable=True)
         self.add_widget('pid_led', QLED, toolbar=self.toolbar)
-        self.add_action('run', 'Run The PID loop', 'run2', tip='run or stop the pid loop', checkable=True)
-        self.add_action('pause', 'Pause the PID loop', 'pause', tip='Pause the PID loop', checkable=True)
+        self.add_action('run', 'Run The PID loop', 'run2', tip='run or stop the pid loop',
+                        checkable=True)
+        self.add_action('pause', 'Pause the PID loop', 'pause', tip='Pause the PID loop',
+                        checkable=True)
         self.set_action_checked('pause', True)
+        self.set_action_enabled('create_setp_actuators', False)
         logger.debug('actions set')
 
     def setup_docks(self):
@@ -297,6 +315,17 @@ class DAQ_PID(CustomApp):
 
         self.dock_pid.addWidget(widget)
 
+    def create_setp_actuators(self):
+        # Now that we have the module manager, load PID if it is checked in managers
+        try:
+            for setp in self.model_class.setpoints_names:
+                self.dashboard.add_move_from_extension(setp, 'PID', PIDController(self))
+            self.set_action_enabled('create_setp_actuators', False)
+
+        except Exception as e:
+            raise PIDError('Could not load the PID extension and create setpoints actuators'
+                           f'{str(e)}')
+
     def get_set_model_params(self, model_name):
         self.settings.child('models', 'model_params').clearChildren()
         models = get_models()
@@ -355,6 +384,7 @@ class DAQ_PID(CustomApp):
             self.enable_controls_pid(True)
             self.get_action('model_led').set_as_true()
             self.set_action_enabled('ini_model', False)
+            self.set_action_enabled('create_setp_actuators', True)
 
         except Exception as e:
             logger.exception(str(e))
@@ -368,10 +398,10 @@ class DAQ_PID(CustomApp):
         for ind, sp in enumerate(self.setpoints_sb):
             sp.setValue(values[ind])
 
-    def setpoints_external(self, values_dict):
+    def setpoints_external(self, values_dict: Dict[str, DataActuator]):
         for key in values_dict:
             index = self.model_class.setpoints_names.index(key)
-            self.setpoints_sb[index].setValue(values_dict[key])
+            self.setpoints_sb[index].setValue(values_dict[key].value())
 
     @property
     def curr_points(self):
@@ -643,38 +673,16 @@ class PIDRunner(QObject):
 
 
 if __name__ == '__main__':
-    import sys
-    from pathlib import Path
-    from pymodaq.utils.daq_utils import get_set_preset_path
-
-    app = QtWidgets.QApplication(sys.argv)
-    if config['style']['darkstyle']:
-        import qdarkstyle
-        app.setStyleSheet(qdarkstyle.load_stylesheet())
-
-    from pymodaq.dashboard import DashBoard
-
-    win = QtWidgets.QMainWindow()
-    area = DockArea()
-    win.setCentralWidget(area)
-    win.resize(1000, 500)
-    win.setWindowTitle('PyMoDAQ Dashboard')
-
-    dashboard = DashBoard(area)
-    pid = None
-    file = Path(get_set_preset_path()).joinpath(f"{config('presets', 'default_preset_for_pid')}.xml")
-    if file.exists():
-        dashboard.set_preset_mode(file)
-        pid = dashboard.load_pid_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 DAQ_PID 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('DAQ_PID')
+    preset_file_name = config('presets', f'default_preset_for_pid')
+
+    dashboard, extension, win = load_dashboard_with_preset(preset_file_name, 'DAQ_PID')
+
+    app.exec()
+
 
 
 

pymodaq/extensions/pid/utils.py

@@ -27,6 +27,7 @@ DAQ_2DViewer_Det_types = get_plugins('daq_2Dviewer')
 DAQ_NDViewer_Det_types = get_plugins('daq_NDviewer')
 
 
+
 class DataToActuatorPID(DataToActuators):
 
     def __init__(self, *args, **kwargs):
@@ -181,8 +182,8 @@ def get_models(model_name=None):
     """
     from pymodaq.extensions.pid.utils import PIDModelGeneric
     models_import = []
-    discovered_models = get_entrypoints(group='pymodaq.pid_models')
-    discovered_models = get_entrypoints(group='pymodaq.models')
+    discovered_models = list(get_entrypoints(group='pymodaq.pid_models'))
+    discovered_models.extend(list(get_entrypoints(group='pymodaq.models')))
     if len(discovered_models) > 0:
         for pkg in discovered_models:
             try:

pymodaq/extensions/utils.py

@@ -8,14 +8,22 @@ import importlib
 from pathlib import Path
 import pkgutil
 import warnings
+from typing import Union, TYPE_CHECKING
 
-from pymodaq_utils.utils import get_entrypoints
+from qtpy import QtCore, QtWidgets
 
+from pymodaq_gui.utils.dock import DockArea
+from pymodaq_utils.utils import get_entrypoints
 from pymodaq_utils import logger as logger_module
+from pymodaq_gui.utils.custom_app import CustomApp
 
+from pymodaq.utils.managers.modules_manager import ModulesManager
 
 logger = logger_module.set_logger(logger_module.get_module_name(__file__))
 
+if TYPE_CHECKING:
+    from pymodaq.dashboard import DashBoard
+
 
 def get_ext_modules(path: Path):
     modules = []
@@ -47,13 +55,39 @@ def get_extensions():
                 module = importlib.import_module(pkg.value)
                 modules = get_ext_modules(Path(module.__path__[0]).joinpath('extensions'))
                 for mod in modules:
-                    mod_in = importlib.import_module(f'{pkg.value}.extensions.{mod}')
-                    if hasattr(mod_in, 'EXTENSION_NAME'):
-                        extension_import.append({'pkg': pkg.value, 'module': mod, 'name': mod_in.EXTENSION_NAME,
-                                                 'class_name': mod_in.CLASS_NAME})
+                    try:
+                        mod_in = importlib.import_module(f'{pkg.value}.extensions.{mod}')
+                        if hasattr(mod_in, 'EXTENSION_NAME'):
+                            extension_import.append({'pkg': pkg.value, 'module': mod,
+                                                     'name': mod_in.EXTENSION_NAME,
+                                                     'class_name': mod_in.CLASS_NAME})
 
-            except Exception as e:  # pragma: no cover
-                logger.warning(f'Impossible to import the {pkg.value}.extensions.{mod} extension: {str(e)}')
+                    except Exception as e:  # pragma: no cover
+                        logger.warning(f'Impossible to import the {pkg.value}.extensions.{mod} extension: '
+                                       f'{str(e)}')
+            except Exception as e:
+                logger.warning(f'Impossible to import the {pkg.value} package: '
+                               f'{str(e)}')
 
     return extension_import
 
+
+class CustomExt(CustomApp):
+
+    def __init__(self, parent: Union[DockArea, QtWidgets.QWidget], dashboard: 'DashBoard'):
+        super().__init__(parent)
+
+        self.dashboard = dashboard
+
+    @property
+    def modules_manager(self) -> ModulesManager:
+        """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/resources/setup_plugin.py

@@ -23,6 +23,7 @@ def setup(path: Path):
         name=PLUGIN_NAME,
         description=config['plugin-info']['description'],
         long_description=long_description,
+        long_description_content_type='text/x-rst',
         license=config['plugin-info']['license'],
         url=config['plugin-info']['package-url'],
         author=config['plugin-info']['author'],

pymodaq/updater.py

@@ -0,0 +1,107 @@
+import argparse
+import subprocess
+import sys
+import time
+import logging
+
+from pathlib import Path
+
+from pymodaq_utils.logger import set_logger, get_module_name
+
+logger = set_logger(get_module_name(__file__))
+logger.addHandler(logging.StreamHandler(sys.stdout))
+
+def wait_for_parent():
+	'''
+		A function to wait for its parent to terminate execution.
+
+		In order to achieve that, this process has to be started with
+		stdin replaced by a piped stream from its parent. When the
+		parent terminates, stdin will close and either return from read
+		or throw an exception. De facto creating a way to wait for its
+		parent's termination.
+
+		It then sleep for 2 seconds, to let the parent process complete
+		termination.
+
+		CAUTION: If the process was not started by piping stdin AND 
+		the --wait option is set, this function will hang forever.
+
+		We could use `psutil` or a similar lib to check for parent's process
+		existance with its pid. 
+	'''
+
+	logger.info("Waiting for parent process to stop.")
+	try:
+		sys.stdin.read()
+	except:
+		pass
+	logger.debug("Parent process closed stdin")
+	time.sleep(2)
+	logger.info("Parent process stopped.")
+
+def process_args():
+	'''
+		Declare arguments for updater.py, parse them and returns them in an object.
+		The arguments are:
+			--file <file> to request a python program to (re)start after update if needed (optional) 
+			--wait        to wait for the starting process to terminate before updating (optional, defaults to False)
+			packages      the package list to install/update (they should contain the version in a pip accepted format)
+	'''
+	parser = argparse.ArgumentParser(description='Update pymodaq using pip.')
+	parser.add_argument('--file', type=str,  help='the pymodaq script to restart after update')
+	parser.add_argument("--wait", action="store_true", help="enable waiting for pymodaq to finish mode (default is disabled).")
+	parser.add_argument('packages', type=str, nargs='+', help='package list')
+	return parser.parse_args()
+
+def restart_if_command_launch(args):
+	'''
+		Try to detect if this process if launched using the declared command (i.e. `pymodaq_updater`)
+		or using the script file (`updater.py`). If it uses the command, it restart the process to
+		force it to use the script file, thus preventing a locked file during update on windows systems.
+	'''
+	python_file_path = Path(__file__) # Should be the path to `updater.py`
+	started_path = Path(sys.argv[0])  # Either `updater.py` or `pymodaq_updater`
+	
+	# If they're different we'll restart using the script file
+	if started_path.absolute() != python_file_path.absolute():
+		logger.info("Started as pymodaq_updater, need to restart using python to prevent lock.")
+		# We HAVE to wait for this process to stop in the restarted process
+		new_args = ['--wait'] + sys.argv[1:]
+		if args.wait:
+			wait_for_parent()
+	
+		subprocess.Popen([sys.executable, str(python_file_path.absolute())] + new_args,  stdin=subprocess.PIPE)
+		sys.exit(0)
+
+def main():
+	args = process_args()
+	logger.info(f"Arguments processed: {args}")
+
+	restart_if_command_launch(args)
+
+	if args.wait:
+		wait_for_parent()
+
+	packages_str = ', '.join(args.packages)
+	logger.info(f'Updating packages: {packages_str}')
+	
+	with subprocess.Popen([sys.executable, '-m', 'pip', 'install'] + args.packages, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) as pip:
+		for line in pip.stdout:
+			# Can't decode as some characters are not valid and make the whole process fail
+			logger.info(line[:-1])
+	ret_code = pip.wait()
+	
+
+	if ret_code == 0:
+		logger.info(f'Succesfully updated {packages_str}')
+	else:
+		logger.error(f'Error while updating {packages_str}, pip returned {ret_code}')
+
+	if args.file is not None:
+		logger.info(f"Restarting {args.file} script after update.")
+		subprocess.Popen([sys.executable, args.file])
+
+
+if __name__ == "__main__":
+	main()

pymodaq/utils/chrono_timer.py

@@ -6,8 +6,7 @@ from qtpy import QtGui, QtWidgets
 from qtpy.QtCore import Qt, QObject, QTimer
 
 
-from pymodaq_gui.utils import DockArea, Dock
-from pymodaq_gui.QtDesigner_Ressources import QtDesigner_ressources_rc
+from pymodaq_gui.utils.dock import DockArea, Dock
 
 
 class PushButtonShortcut(QtWidgets.QPushButton):
@@ -64,7 +63,7 @@ class ChronoTimer(QObject):
 
         self.dock_chrono_timer.setAutoFillBackground(True)
         palette = self.dock_chrono_timer.palette()
-        palette.setColor(palette.Background, QtGui.QColor(0, 0, 0))
+        palette.setColor(palette.Window, QtGui.QColor(0, 0, 0))
         self.dock_chrono_timer.setPalette(palette)
 
         self.time_lcd = QtWidgets.QLCDNumber(8)
@@ -92,7 +91,7 @@ class ChronoTimer(QObject):
         self.controls_layout.addWidget(hor_widget)
 
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/run2.png"), QtGui.QIcon.Normal,
+        icon.addPixmap(QtGui.QPixmap("icons:run2.png"), QtGui.QIcon.Normal,
                        QtGui.QIcon.Off)
         self.start_pb = PushButtonShortcut(icon, 'Start',
                                            shortcut='Home', shortcut_widget=self.area)
@@ -102,7 +101,7 @@ class ChronoTimer(QObject):
         hor_layout.addWidget(self.start_pb)
 
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/pause.png"), QtGui.QIcon.Normal,
+        icon.addPixmap(QtGui.QPixmap("icons:pause.png"), QtGui.QIcon.Normal,
                        QtGui.QIcon.Off)
         self.pause_pb = PushButtonShortcut(icon, 'Pause',
                                            shortcut='Ctrl+p', shortcut_widget=self.area)
@@ -112,7 +111,7 @@ class ChronoTimer(QObject):
         hor_layout.addWidget(self.pause_pb)
 
         icon = QtGui.QIcon()
-        icon.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/Refresh2.png"), QtGui.QIcon.Normal,
+        icon.addPixmap(QtGui.QPixmap("icons:Refresh2.png"), QtGui.QIcon.Normal,
                        QtGui.QIcon.Off)
         self.reset_pb = PushButtonShortcut(icon, 'Reset',
                                            shortcut='F5', shortcut_widget=self.area)
@@ -184,7 +183,7 @@ class ChronoTimer(QObject):
         # lcd.setPalette(QtGui.QPalette(Qt.red))
         if hasattr(Qt, color):
             palette.setBrush(palette.WindowText, getattr(Qt, color))
-            palette.setColor(palette.Background, QtGui.QColor(0, 0, 0))
+            palette.setColor(palette.Window, QtGui.QColor(0, 0, 0))
         lcd.setPalette(palette)
 
 

pymodaq/utils/daq_utils.py

@@ -5,9 +5,11 @@ import pkgutil
 import platform
 from pathlib import Path
 
-from pymodaq_utils import logger as logger_module
 from pymodaq_utils.config import Config
-from pymodaq_utils.utils import get_entrypoints, ThreadCommand, getLineInfo
+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
 
@@ -18,7 +20,7 @@ else:
     from functools import lru_cache as cache
 
 
-logger = logger_module.set_logger(logger_module.get_module_name(__file__))
+logger = set_logger(get_module_name(__file__))
 
 config = Config()
 
@@ -122,6 +124,7 @@ def get_instrument_plugins():  # pragma: no cover
     except Exception as e:
         logger.debug(f'Impossible to import PID utility plugin: {str(e)}')
 
+    plugins_import.sort(key=lambda mod: mod['name'])
     return plugins_import
 
 

pymodaq/utils/data.py

@@ -1,13 +1,15 @@
 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)
+                               DataSource, DataBase, Axis, NavAxis, DataDistribution, Q_, Unit,
+                               )  # imported here for backcompatibility
 
 
 class DataActuator(DataRaw):
@@ -24,25 +26,18 @@ class DataActuator(DataRaw):
 
     def __repr__(self):
         if self.dim.name == 'Data0D':
-            return f'<{self.__class__.__name__} ({self.data[0][0]})>'
+            return f'<{self.__class__.__name__} ({self.data[0][0]} {self.units})>'
         else:
-            return f'<{self.__class__.__name__} ({self.shape})>'
+            return f'<{self.__class__.__name__} ({self.shape} {self.units})>'
 
-    def value(self) -> float:
-        """Returns the underlying float value (of the first elt in the data list) if this data
-        holds only a float otherwise returns a mean of the underlying data"""
-        if self.length == 1 and self.size == 1:
-            return float(self.data[0][0])
-        else:
-            return float(np.mean(self.data))
+    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
 
-    def values(self) -> List[float]:
-        """Returns the underlying float value (for each data array in the data list) if this data
-        holds only a float otherwise returns a mean of the underlying data"""
-        if self.length == 1 and self.size == 1:
-            return [float(data_array[0]) for data_array in self.data]
         else:
-            return [float(np.mean(data_array)) for data_array in self.data]
+            return super().__add__(other)
 
 
 class DataFromPlugins(DataRaw):

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/gui_utils/loader_utils.py

@@ -5,14 +5,35 @@ 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
+from pymodaq.extensions.utils import CustomExt
 
 
-def load_dashboard_with_preset(preset_name: str, extension_name: str):
+def load_dashboard_with_preset(preset_name: str, extension_name: str) -> \
+        (DashBoard, CustomExt, QtWidgets.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 = QtWidgets.QMainWindow()
     area = DockArea()
     win.setCentralWidget(area)
     win.resize(1000, 500)
-    win.setWindowTitle('PyMoDAQ Dashboard')
+    win.setWindowTitle('extension_name')
     win.show()
 
     # win.setVisible(False)
@@ -26,6 +47,10 @@ def load_dashboard_with_preset(preset_name: str, extension_name: str):
             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()
         else:
             extension = dashboard.load_extension_from_name(extension_name)
     else:

pymodaq/utils/gui_utils/utils.py

@@ -1,21 +1,18 @@
-import sys
-
-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.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')
 
-def get_splash_sc():
-    here = Path(__file__)
-    splash_sc = QtWidgets.QSplashScreen(
-        QtGui.QPixmap(str(here.parent.parent.parent.joinpath('splash.png'))),
-        Qt.WindowStaysOnTopHint)
-    return splash_sc
 
 

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')