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

pymodaq/__init__.py

@@ -6,23 +6,11 @@ from pathlib import Path
 
 import warnings
 
+import pymodaq_utils  # to init stuff related to pymodaq_utils  # necessary, leave it there
+import pymodaq_data  # to init stuff related to pymodaq_data  # necessary, leave it there
+import pymodaq_gui  # to init stuff related to pymodaq_gui  # necessary, leave it there
 
-def check_qt_presence():
-    try:
-        from qtpy import QtWidgets
-    except ImportError as e:
-        msg = f"\n\n" \
-              f"****************************************************************************************\n" \
-              f"No Qt backend could be found in your system, please install either pyqt5/6 or pyside2/6.\n\n" \
-              f"pyqt5 is still preferred, while pyqt6 should mostly work.\n\n" \
-              f"do:\n" \
-              f"pip install pyqt5\n for instance\n"\
-              f"****************************************************************************************\n"
-        warnings.warn(msg, FutureWarning, 2)
-        sys.exit()
-
-
-check_qt_presence()
+from pymodaq_data import Q_, Unit, ureg  # necessary, leave it there
 
 
 try:
@@ -31,87 +19,65 @@ try:
 
     from pymodaq_utils.logger import set_logger
     from pymodaq_utils.utils import get_version
-    __version__ = get_version()
+    __version__ = get_version('pymodaq')
     try:
         logger = set_logger('pymodaq', add_handler=True, base_logger=True)
-    except Exception:
-        print("Couldn't create the local folder to store logs , presets...")
 
-    logger.info('')
-    logger.info('')
-    logger.info('************************')
-    logger.info('Starting PyMoDAQ modules')
-    logger.info('************************')
-    logger.info('')
-    logger.info('')
-    logger.info('************************')
-    logger.info('Initializing the pint unit register')
-    logger.info('************************')
-    ureg = UnitRegistry()
-    ureg.default_format = '~'
-    Q_ = ureg.Quantity
-    Unit = ureg.Unit
-    logger.info('')
-    logger.info('')
-
-    # in a try statement for compilation on readthedocs server but if this fail, you cannot use the code
-    from pymodaq_gui.plotting import data_viewers  # imported here as to avoid circular imports later on
-    from pymodaq_gui.qt_utils import setLocale, set_qt_backend
-    from pymodaq.utils.daq_utils import copy_preset, get_instrument_plugins
-
-    from pymodaq_utils.config import Config
-    from pymodaq.utils.scanner.utils import register_scanners
-    from pymodaq_data.plotting.plotter.plotter import register_plotter, PlotterFactory
-
-    # issue on windows when using .NET code within multithreads, this below allows it but requires
-    # the pywin32 (pythoncom) package
-    if importlib.util.find_spec('clr') is not None:
+        from pymodaq.utils.daq_utils import copy_preset, get_instrument_plugins
+
+        from pymodaq_utils.config import Config
+        from pymodaq.utils.scanner.utils import register_scanners
+        from pymodaq_data.plotting.plotter.plotter import register_plotter, PlotterFactory
+
+        # issue on windows when using .NET code within multithreads, this below allows it but requires
+        # the pywin32 (pythoncom) package
+        if importlib.util.find_spec('clr') is not None:
+            try:
+                import pythoncom
+                pythoncom.CoInitialize()
+            except ModuleNotFoundError as e:
+                infos = "You have installed plugins requiring the pywin32 package to work correctly," \
+                        " please type in *pip install pywin32* and restart PyMoDAQ"
+                print(infos)
+                logger.warning(infos)
+
+        config = Config()  # to ckeck for config file existence, otherwise create one
+        copy_preset()
+
+        from pymodaq_utils.config import Config
+        from pymodaq.utils.scanner.utils import register_scanners
+
         try:
-            import pythoncom
-            pythoncom.CoInitialize()
+            # Need the config to exists before importing
+            from pymodaq_utils.environment import EnvironmentBackupManager
+
+            if config['backup']['keep_backup']:
+                ebm = EnvironmentBackupManager()
+                ebm.save_backup()
         except ModuleNotFoundError as e:
-            infos = "You have installed plugins requiring the pywin32 package to work correctly," \
-                    " please type in *pip install pywin32* and restart PyMoDAQ"
+            infos = "Your pymodaq_utils version is outdated and doesn't allow for automatic backup of pip packages." \
+                    " You should update it."
             print(infos)
             logger.warning(infos)
 
-    config = Config()  # to ckeck for config file existence, otherwise create one
-    copy_preset()
-
-    logger.info('************************')
-    logger.info(f"Setting Qt backend to: {config['qtbackend']['backend']} ...")
-    set_qt_backend()
-    logger.info('************************')
-    logger.info('')
-    logger.info('')
-    logger.info('************************')
-    logger.info(f"Setting Locale to {config['style']['language']} / {config['style']['country']}")
-    logger.info('************************')
-    setLocale()
-    logger.info('')
-    logger.info('')
-
-    logger.info('*************************************************************************')
-    logger.info(f"Getting the list of instrument plugins...")
-    logger.info('')
-    get_instrument_plugins()
-    logger.info('*************************************************************************')
-
-    logger.info('')
-    logger.info('')
-    logger.info('************************')
-    logger.info(f"Registering Scanners...")
-    register_scanners()
-    logger.info(f"Done")
-    logger.info('************************')
-
-    logger.info('')
-    logger.info('')
-    logger.info('************************')
-    logger.info(f"Registering plotters...")
-    register_plotter()
-    logger.info(f"Done")
-    logger.info('************************')
+        logger.info('*************************************************************************')
+        logger.info(f"Getting the list of instrument plugins...")
+        logger.info('')
+        get_instrument_plugins()
+        logger.info('*************************************************************************')
+
+        logger.info('')
+        logger.info('')
+        logger.info('************************')
+        logger.info(f"Registering Scanners...")
+        register_scanners()
+        logger.info(f"Done")
+        logger.info('************************')
+
+    except Exception:
+        print("Couldn't create the local folder to store logs , presets...")
+
+
 
 except Exception as e:
     try:

pymodaq/control_modules/daq_move.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import numbers
 from importlib import import_module
 from numbers import Number
-from random import randint
+
 import sys
 from typing import List, Tuple, Union, Optional, Type
 import numpy as np
@@ -32,14 +32,22 @@ from pymodaq_data.h5modules.backends import Node
 
 from pymodaq_gui.parameter import ioxml, Parameter
 from pymodaq_gui.parameter import utils as putils
+from pymodaq_gui.utils.utils import mkQApp
 
 from pymodaq.utils.h5modules import module_saving
 from pymodaq.control_modules.utils import ParameterControlModule
-from pymodaq.control_modules.daq_move_ui import DAQ_Move_UI
-from pymodaq.control_modules.move_utility_classes import MoveCommand, DAQ_Move_base
+from pymodaq.control_modules.daq_move_ui import DAQ_Move_UI, ThreadCommand
+from pymodaq.control_modules.move_utility_classes import (MoveCommand, DAQ_Move_base,
+                                                          DataActuatorType, check_units,
+                                                          DataUnitError)
+
+
 from pymodaq.control_modules.move_utility_classes import params as daq_move_params
 from pymodaq.utils.leco.pymodaq_listener import MoveActorListener, LECOMoveCommands
+
 from pymodaq.utils.daq_utils import get_plugins
+from pymodaq import Q_, Unit
+
 
 
 local_path = config_mod.get_set_local_dir()
@@ -116,15 +124,15 @@ class DAQ_Move(ParameterControlModule):
         self.splash_sc = get_splash_sc()
         self._title = title
         if len(ACTUATOR_TYPES) > 0:  # will be 0 if no valid plugins are installed
-            self.actuator = ACTUATOR_TYPES[0]
+            self.actuator = kwargs.get('actuator', ACTUATOR_TYPES[0])
 
         self.module_and_data_saver = module_saving.ActuatorSaver(self)
 
         self._move_done_bool = True
 
-        self._current_value = DataActuator(title)
-        self._target_value: DataActuator(title)
-        self._relative_value: DataActuator(title)
+        self._current_value = DataActuator(title, units=self.units)
+        self._target_value = DataActuator(title, units=self.units)
+        self._relative_value = DataActuator(title, units=self.units)
 
         self._refresh_timer = QTimer()
         self._refresh_timer.timeout.connect(self.get_actuator_value)
@@ -162,9 +170,15 @@ class DAQ_Move(ParameterControlModule):
         elif cmd.command == 'stop':
             self.stop_motion()
         elif cmd.command == 'move_abs':
-            self.move_abs(cmd.attribute)
+            data_act: DataActuator = cmd.attribute
+            if not Unit(data_act.units).is_compatible_with(self.units) and data_act.units != '':
+                data_act.force_units(self.units)
+            self.move_abs(data_act)
         elif cmd.command == 'move_rel':
-            self.move_rel(cmd.attribute)
+            data_act: DataActuator = cmd.attribute
+            if not Unit(data_act.units).is_compatible_with(self.units) and data_act.units != '':
+                data_act.force_units(self.units)
+            self.move_rel(data_act)
         elif cmd.command == 'show_log':
             self.show_log()
         elif cmd.command == 'show_config':
@@ -175,6 +189,20 @@ class DAQ_Move(ParameterControlModule):
         elif cmd.command == 'rel_value':
             self._relative_value = cmd.attribute
 
+    @property
+    def master(self) -> bool:
+        """ Get/Set programmatically the Master/Slave status of an actuator"""
+        if self.initialized_state:
+            return self.settings['move_settings', 'multiaxes', 'multi_status'] == 'Master'
+        else:
+            return True
+
+    @master.setter
+    def master(self, is_master: bool):
+        if self.initialized_state:
+            self.settings.child('move_settings', 'multiaxes', 'multi_status').setValue(
+                'Master' if is_master else 'Slave')
+
     def append_data(self, dte: Optional[DataToExport] = None, where: Union[Node, str, None] = None):
         """Appends current DataToExport to an ActuatorEnlargeableSaver
 
@@ -258,7 +286,7 @@ class DAQ_Move(ParameterControlModule):
         """
         try:
             if isinstance(value, Number):
-                value = DataActuator(self.title, data=[np.array([value])])
+                value = DataActuator(self.title, data=[np.array([value])], units=self.units)
             self._send_to_tcpip = send_to_tcpip
             if value != self._current_value:
                 if self.ui is not None:
@@ -307,7 +335,7 @@ class DAQ_Move(ParameterControlModule):
 
         try:
             if isinstance(rel_value, Number):
-                rel_value = DataActuator(self.title, data=[np.array([rel_value])])
+                rel_value = DataActuator(self.title, data=[np.array([rel_value])], units=self.units)
             self._send_to_tcpip = send_to_tcpip
             if self.ui is not None:
                 self.ui.move_done = False
@@ -362,8 +390,9 @@ class DAQ_Move(ParameterControlModule):
                 self._hardware_thread.hardware = hardware
                 self._hardware_thread.start()
                 self.command_hardware.emit(
-                    ThreadCommand(command="ini_stage", attribute=[self.settings.child('move_settings').saveState(),
-                                                                  self.controller]))
+                    ThreadCommand(command="ini_stage", attribute=[
+                        self.settings.child('move_settings').saveState(),
+                        self.controller]))
             except Exception as e:
                 self.logger.exception(str(e))
 
@@ -429,11 +458,10 @@ class DAQ_Move(ParameterControlModule):
         super().thread_status(status, 'move')
 
         if status.command == "ini_stage":
-            # status.attribute[0]=edict(initialized=bool,info="", controller=)
-            self.update_status("Stage initialized: {:} info: {:}".format(status.attribute[0]['initialized'],
-                                                                         status.attribute[0]['info']))
-            if status.attribute[0]['initialized']:
-                self.controller = status.attribute[0]['controller']
+            self.update_status(f"Stage initialized: {status.attribute['initialized']} "
+                               f"info: {status.attribute['info']}")
+            if status.attribute['initialized']:
+                self.controller = status.attribute['controller']
                 if self.ui is not None:
                     self.ui.actuator_init = True
                 self._initialized_state = True
@@ -444,8 +472,7 @@ class DAQ_Move(ParameterControlModule):
             self.init_signal.emit(self._initialized_state)
 
         elif status.command == "get_actuator_value" or status.command == 'check_position':
-            data_act: DataActuator = status.attribute[0]
-            data_act.name = self.title  # for the DataActuator name to be the title of the DAQ_Move
+            data_act = self._check_data_type(status.attribute)
             if self.ui is not None:
                 self.ui.display_value(data_act)
                 if self.ui.is_action_checked('show_graph'):
@@ -454,13 +481,12 @@ class DAQ_Move(ParameterControlModule):
             self._current_value = data_act
             self.current_value_signal.emit(self._current_value)
             if self.settings['main_settings', 'tcpip', 'tcp_connected'] and self._send_to_tcpip:
-                self._command_tcpip.emit(ThreadCommand('position_is', status.attribute))
+                self._command_tcpip.emit(ThreadCommand('position_is', data_act))
             if self.settings['main_settings', 'leco', 'leco_connected'] and self._send_to_tcpip:
-                self._command_tcpip.emit(ThreadCommand(LECOMoveCommands.POSITION, status.attribute))
+                self._command_tcpip.emit(ThreadCommand(LECOMoveCommands.POSITION, data_act))
 
         elif status.command == "move_done":
-            data_act: DataActuator = status.attribute[0]
-            data_act.name = self.title  # for the DataActuator name to be the title of the DAQ_Move
+            data_act = self._check_data_type(status.attribute)
             if self.ui is not None:
                 self.ui.display_value(data_act)
                 self.ui.move_done = True
@@ -468,9 +494,9 @@ class DAQ_Move(ParameterControlModule):
             self._move_done_bool = True
             self.move_done_signal.emit(data_act)
             if self.settings.child('main_settings', 'tcpip', 'tcp_connected').value() and self._send_to_tcpip:
-                self._command_tcpip.emit(ThreadCommand('move_done', status.attribute))
+                self._command_tcpip.emit(ThreadCommand('move_done', data_act))
             if self.settings.child('main_settings', 'leco', 'leco_connected').value() and self._send_to_tcpip:
-                self._command_tcpip.emit(ThreadCommand(LECOMoveCommands.MOVE_DONE, status.attribute))
+                self._command_tcpip.emit(ThreadCommand(LECOMoveCommands.MOVE_DONE, data_act))
 
         elif status.command == 'outofbounds':
             self.bounds_signal.emit(True)
@@ -485,6 +511,22 @@ class DAQ_Move(ParameterControlModule):
         elif status.command == 'units':
             self.units = status.attribute
 
+    def _check_data_type(self, data_act: Union[list[np.ndarray], float, DataActuator]) -> DataActuator:
+        """ Make sure the data is a DataActuator
+
+        Mostly to make sure DAQ_Move is backcompatible with old style plugins
+        """
+        if isinstance(data_act, list):  # backcompatibility
+            data_act = data_act[0]
+        if isinstance(data_act, np.ndarray):  # backcompatibility
+            data_act = DataActuator(data=[data_act], units=self.units)
+        data_act.name = self.title  # for the DataActuator name to be the title of the DAQ_Move
+        if (not Unit(self.units).is_compatible_with(Unit(data_act.units)) and
+                data_act.units == ''):  #this happens if the units have not been specified in
+            # the plugin
+            data_act.force_units(self.units)
+        return  data_act
+
     def get_actuator_value(self):
         """Get the current actuator value via the "get_actuator_value" command send to the hardware
 
@@ -545,10 +587,15 @@ class DAQ_Move(ParameterControlModule):
             self.update_plugin_config()
             if self.ui is not None:
                 self.ui.actuator = act_type
-                self.update_settings()
+            self.update_settings()
         else:
             raise ActuatorError(f'{act_type} is an invalid actuator, should be within {ACTUATOR_TYPES}')
 
+    @property
+    def actuators(self) -> List[str]:
+        """ Get the list of possible actuators"""
+        return ACTUATOR_TYPES
+
     def update_plugin_config(self):
         parent_module = utils.find_dict_in_list_from_key_val(DAQ_Move_Actuators, 'name', self.actuator)
         mod = import_module(parent_module['module'].__package__.split('.')[0])
@@ -564,7 +611,35 @@ class DAQ_Move(ParameterControlModule):
     def units(self, unit: str):
         self.settings.child('move_settings', 'units').setValue(unit)
         if self.ui is not None and config('actuator', 'display_units'):
-            self.ui.set_unit_as_suffix(unit)
+            self.ui.set_unit_as_suffix(self.get_unit_to_display(unit))
+
+    @staticmethod
+    def get_unit_to_display(unit: str) -> str:
+        """ Get the unit to be displayed in the UI
+
+        If the controller units are in mm the displayed unit will be m
+        because m is the base unit, then the user could ask for mm, km, µm...
+        only issue is when the usual displayed unit is not the base one, then add cases below
+
+        Parameters
+        ----------
+        unit: str
+
+        Returns
+        -------
+        str: the unit to be displayed on the ui
+        """
+        if ('°' in unit or 'degree' in unit) and not '°C' in unit:
+            # special cas as pint base unit for angles are radians
+            return '°'
+        elif 'W' in unit or 'watt' in unit.lower():
+            return 'W'
+        elif '°C' in unit or 'Celsius' in unit:
+            return '°C'
+        elif 'V' in unit or 'volt' in unit.lower():
+            return 'V'
+        else:
+            return str(Q_(1, unit).to_base_units().units)
 
     def update_settings(self):
 
@@ -641,8 +716,6 @@ class DAQ_Move_Hardware(QObject):
         self._title = title
         self.hardware: Optional[DAQ_Move_base] = None
         self.actuator_type = actuator_type
-        self.current_position: DataActuator = position
-        self._target_value: Optional[DataActuator] = None
         self.hardware_adress = None
         self.axis_address = None
         self.motion_stoped = False
@@ -656,17 +729,18 @@ class DAQ_Move_Hardware(QObject):
             Uninitialize the stage closing the hardware.
 
         """
-        self.hardware.close()
+        if self.hardware is not None and self.hardware.controller is not None:
+            self.hardware.close()
 
         return "Stage uninitialized"
 
     def get_actuator_value(self):
         """Get the current position checking the hardware value.
         """
-        pos = self.hardware.get_actuator_value()
-        if self.hardware.data_actuator_type.name == 'float':
-            return DataActuator(self._title, data=pos)
-        else:
+        if self.hardware is not None:
+            pos = self.hardware.get_actuator_value()
+            if self.hardware.data_actuator_type == DataActuatorType.float:
+                pos = DataActuator(self._title, data=pos, units=self.hardware.axis_unit)
             return pos
 
     def check_position(self):
@@ -716,6 +790,8 @@ class DAQ_Move_Hardware(QObject):
                 status.initialized = infos[1]
             status.controller = self.hardware.controller
             self.hardware.move_done_signal.connect(self.move_done)
+            if status.initialized:
+                self.status_sig.emit(ThreadCommand('get_actuator_value', [self.get_actuator_value()]))
 
             return status
         except Exception as e:
@@ -726,15 +802,13 @@ class DAQ_Move_Hardware(QObject):
         """
 
         """
-        # if isinstance(position, Number):
-        #     position = float(position)  # because it may be a numpy float and could cause issues
-        #     # see https://github.com/pythonnet/pythonnet/issues/1833
-        self._target_value = position
+        position = check_units(position, self.hardware.axis_unit)
         self.hardware.move_is_done = False
         self.hardware.ispolling = polling
         if self.hardware.data_actuator_type.name == 'float':
             self.hardware.move_abs(position.value())
         else:
+            position.units = self.hardware.axis_unit  # convert to plugin controller current axis units
             self.hardware.move_abs(position)
         self.hardware.poll_moving()
 
@@ -742,14 +816,14 @@ class DAQ_Move_Hardware(QObject):
         """
 
         """
-
+        rel_position = check_units(rel_position, self.hardware.axis_unit)
         self.hardware.move_is_done = False
-        self._target_value = self.current_position + rel_position
         self.hardware.ispolling = polling
 
         if self.hardware.data_actuator_type.name == 'float':
             self.hardware.move_rel(rel_position.value())
         else:
+            rel_position.units = self.hardware.axis_unit  # convert to plugin current axis units
             self.hardware.move_rel(rel_position)
 
         self.hardware.poll_moving()
@@ -763,7 +837,7 @@ class DAQ_Move_Hardware(QObject):
             --------
             DAQ_utils.ThreadCommand
         """
-        self.status_sig.emit(ThreadCommand("move_done", [pos]))
+        self.status_sig.emit(ThreadCommand("move_done", pos))
 
     def move_home(self):
         """
@@ -771,7 +845,6 @@ class DAQ_Move_Hardware(QObject):
 
         """
         self.hardware.move_is_done = False
-        self._target_value = 0
         self.hardware.move_home()
 
     @Slot(DataActuator)
@@ -779,7 +852,7 @@ class DAQ_Move_Hardware(QObject):
         """Send the move_done signal back to the main class
         """
         self._current_value = pos
-        self.status_sig.emit(ThreadCommand(command="move_done", attribute=[pos]))
+        self.status_sig.emit(ThreadCommand(command="move_done", attribute=pos))
 
     @Slot(ThreadCommand)
     def queue_command(self, command: ThreadCommand):
@@ -807,10 +880,10 @@ class DAQ_Move_Hardware(QObject):
             * **reset_stop_motion** command, set the motion_stopped attribute to false
         """
         try:
+            logger.debug(f'Threadcommand {command.command} sent to {self.title}')
             if command.command == "ini_stage":
-                status = self.ini_stage(
-                    *command.attribute)  # return edict(initialized=bool,info="", controller=, stage=)
-                self.status_sig.emit(ThreadCommand(command=command.command, attribute=[status, 'log']))
+                status: edict = self.ini_stage(*command.attribute)
+                self.status_sig.emit(ThreadCommand(command=command.command, attribute=status))
 
             elif command.command == "close":
                 status = self.close()
@@ -838,11 +911,13 @@ class DAQ_Move_Hardware(QObject):
             else:  # custom commands for particular plugins (see spectrometer module 'get_spectro_wl' for instance)
                 if hasattr(self.hardware, command.command):
                     cmd = getattr(self.hardware, command.command)
-                    cmd(*command.attribute)
+                    if isinstance(command.attribute, list):
+                        cmd(*command.attribute)
+                    elif isinstance(command.attribute, dict):
+                        cmd(**command.attribute)
         except Exception as e:
             self.logger.exception(str(e))
 
-
     def stop_motion(self):
         """
             stop hardware motion with motion_stopped attribute updtaed to True and a status signal sended with an "update_status" Thread Command
@@ -853,7 +928,8 @@ class DAQ_Move_Hardware(QObject):
         """
         self.status_sig.emit(ThreadCommand(command="Update_Status", attribute=["Motion stoping", 'log']))
         self.motion_stoped = True
-        self.hardware.stop_motion()
+        if self.hardware is not None and self.hardware.controller is not None:
+            self.hardware.stop_motion()
         self.hardware.poll_timer.stop()
 
     @Slot(edict)
@@ -879,15 +955,13 @@ class DAQ_Move_Hardware(QObject):
                 setattr(self, path[-1], param.value())
 
         elif path[0] == 'move_settings':
-            self.hardware.update_settings(settings_parameter_dict)
+            if self.hardware is not None:
+                self.hardware.update_settings(settings_parameter_dict)
 
 
 def main(init_qt=True):
     if init_qt:  # used for the test suite
-        app = QtWidgets.QApplication(sys.argv)
-        if config('style', 'darkstyle'):
-            import qdarkstyle
-            app.setStyleSheet(qdarkstyle.load_stylesheet(qdarkstyle.DarkPalette))
+        app = mkQApp("PyMoDAQ Move")
 
     widget = QtWidgets.QWidget()
     prog = DAQ_Move(widget, title="test")