pymodaq 4.3.4__tar.gz → 4.3.6__tar.gz

{pymodaq-4.3.4 → pymodaq-4.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymodaq
-Version: 4.3.4
+Version: 4.3.6
 Summary: Modular Data Acquisition with Python
 Project-URL: Homepage, http://pymodaq.cnrs.fr
 Project-URL: Source, https://github.com/PyMoDAQ/PyMoDAQ

{pymodaq-4.3.4 → pymodaq-4.3.6}/src/pymodaq/control_modules/daq_move.py

@@ -23,7 +23,7 @@ from easydict import EasyDict as edict
 from pymodaq.utils.logger import set_logger, get_module_name
 from pymodaq.control_modules.utils import ParameterControlModule
 from pymodaq.control_modules.daq_move_ui import DAQ_Move_UI, ThreadCommand
-from pymodaq.control_modules.move_utility_classes import MoveCommand, DAQ_Move_base
+from pymodaq.control_modules.move_utility_classes import MoveCommand, DAQ_Move_base, DataActuatorType
 from pymodaq.control_modules.move_utility_classes import params as daq_move_params
 from pymodaq.utils import daq_utils as utils
 from pymodaq.utils.parameter import utils as putils
@@ -37,6 +37,7 @@ from pymodaq.utils.h5modules.backends import Node
 from pymodaq.utils.parameter import ioxml, Parameter
 
 from pymodaq.utils.leco.pymodaq_listener import MoveActorListener, LECOMoveCommands
+from pymodaq import Q_, Unit
 
 
 local_path = config_mod.get_set_local_dir()
@@ -119,9 +120,9 @@ class DAQ_Move(ParameterControlModule):
 
         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)
@@ -159,9 +160,13 @@ 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
+            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
+            data_act.force_units(self.units)
+            self.move_rel(data_act)
         elif cmd.command == 'show_log':
             self.show_log()
         elif cmd.command == 'show_config':
@@ -174,7 +179,7 @@ class DAQ_Move(ParameterControlModule):
 
     @property
     def master(self) -> bool:
-        """ Get/Set programmaticaly the Master/Slave status of an actuator"""
+        """ Get/Set programmatically the Master/Slave status of an actuator"""
         if self.initialized_state:
             return self.settings['move_settings', 'multiaxes', 'multi_status'] == 'Master'
         else:
@@ -269,7 +274,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:
@@ -318,7 +323,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
@@ -458,6 +463,11 @@ class DAQ_Move(ParameterControlModule):
         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
+            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)
+
             if self.ui is not None:
                 self.ui.display_value(data_act)
                 if self.ui.is_action_checked('show_graph'):
@@ -557,7 +567,7 @@ 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}')
 
@@ -681,8 +691,8 @@ class DAQ_Move_Hardware(QObject):
         """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)
+        if self.hardware.data_actuator_type == DataActuatorType.float:
+            return DataActuator(self._title, data=pos, units=self.units)
         else:
             return pos
 

{pymodaq-4.3.4 → pymodaq-4.3.6}/src/pymodaq/control_modules/move_utility_classes.py

@@ -17,10 +17,11 @@ from pymodaq.utils.daq_utils import ThreadCommand, getLineInfo, find_keys_from_v
 from pymodaq.utils import config as configmod
 from pymodaq.utils.tcp_ip.tcp_server_client import TCPServer, tcp_parameters
 from pymodaq.utils.messenger import deprecation_msg
-from pymodaq.utils.data import DataActuator
+from pymodaq.utils.data import DataActuator, DataUnitError
 from pymodaq.utils.enums import BaseEnum, enum_checker
 from pymodaq.utils.tcp_ip.mysocket import Socket
 from pymodaq.utils.tcp_ip.serializer import DeSerializer, Serializer
+from pymodaq import Unit
 
 if TYPE_CHECKING:
     from pymodaq.control_modules.daq_move import DAQ_Move_Hardware
@@ -207,7 +208,7 @@ class DAQ_Move_base(QObject):
     params = []
     _controller_units = ''
     _epsilon = 1
-    data_actuator_type = DataActuatorType['float']
+    data_actuator_type = DataActuatorType.float
     data_shape = (1, )  # expected shape of the underlying actuator's value (in general a float so shape = (1, ))
 
     def __init__(self, parent: Optional['DAQ_Move_Hardware'] = None,
@@ -235,8 +236,12 @@ class DAQ_Move_base(QObject):
             self._title = parent.title
         else:
             self._title = "myactuator"
-        self._current_value = DataActuator(self._title, data=[np.zeros(self.data_shape, dtype=float)])
-        self._target_value = DataActuator(self._title, data=[np.zeros(self.data_shape, dtype=float)])
+        self._current_value = DataActuator(self._title,
+                                           data=[np.zeros(self.data_shape, dtype=float)],
+                                           units=self.controller_units)
+        self._target_value = DataActuator(self._title,
+                                          data=[np.zeros(self.data_shape, dtype=float)],
+                                          units=self.controller_units)
         self.controller_units = self._controller_units
 
         self.poll_timer = QTimer()
@@ -289,7 +294,7 @@ class DAQ_Move_base(QObject):
         """ To be subclassed, in order to init specific attributes needed by the real implementation"""
         self.controller = None
 
-    def ini_stage_init(self, old_controller=None, new_controller=None):
+    def ini_stage_init(self, old_controller=None, new_controller=None, slave_controller=None):
         """Manage the Master/Slave controller issue
 
         First initialize the status dictionary
@@ -307,8 +312,11 @@ class DAQ_Move_base(QObject):
             The particular object that allow the communication with the hardware, in general a python wrapper around the
             hardware library. In case of Master it is the new instance of your plugin controller
         """
+        if old_controller is None and slave_controller is not None:
+            old_controller = slave_controller
+
         self.status.update(edict(info="", controller=None, initialized=False))
-        if self.settings['multiaxes', 'ismultiaxes'] and self.settings['multiaxes', 'multi_status'] == "Slave":
+        if self.settings['multiaxes', 'ismultiaxes'] and not self.is_master:
             if old_controller is None:
                 raise Exception('no controller has been defined externally while this axe is a slave one')
             else:
@@ -328,8 +336,13 @@ class DAQ_Move_base(QObject):
     @current_value.setter
     def current_value(self, value: Union[float, DataActuator]):
         if not isinstance(value, DataActuator):
-            self._current_value = DataActuator(self._title, data=value)
+            self._current_value = DataActuator(self._title, data=value,
+                                               units=self.controller_units)
         else:
+            if (not Unit(self.controller_units).is_compatible_with(
+                    Unit(value.units)) and
+                    value.units == ''):
+                value.force_units(self.controller_units)
             self._current_value = value
 
     @property
@@ -342,8 +355,13 @@ class DAQ_Move_base(QObject):
     @target_value.setter
     def target_value(self, value: Union[float, DataActuator]):
         if not isinstance(value, DataActuator):
-            self._target_value = DataActuator(self._title, data=value)
+            self._target_value = DataActuator(self._title, data=value,
+                                              units=self.controller_units)
         else:
+            if (not Unit(self.controller_units).is_compatible_with(
+                    Unit(value.units)) and
+                    value.units == ''):
+                value.force_units(self.controller_units)
             self._target_value = value
 
     @property
@@ -402,10 +420,15 @@ class DAQ_Move_base(QObject):
         """
         if self.settings.child('bounds', 'is_bounds').value():
             if position > self.settings.child('bounds', 'max_bound').value():
-                position = DataActuator(self._title, data=self.settings.child('bounds', 'max_bound').value())
+                position = DataActuator(self._title,
+                                        data=self.settings.child('bounds', 'max_bound').value(),
+                                        units = self.controller_units)
                 self.emit_status(ThreadCommand('outofbounds', []))
             elif position < self.settings.child('bounds', 'min_bound').value():
-                position = DataActuator(self._title, data=self.settings.child('bounds', 'min_bound').value())
+                position = DataActuator(self._title,
+                                        data=self.settings.child('bounds', 'min_bound').value(),
+                                        units=self.controller_units
+                                        )
                 self.emit_status(ThreadCommand('outofbounds', []))
         return position
 
@@ -472,12 +495,14 @@ class DAQ_Move_base(QObject):
         """
         if position is None:
             if self.data_actuator_type.name == 'float':
-                position = DataActuator(self._title, data=self.get_actuator_value())
+                position = DataActuator(self._title, data=self.get_actuator_value(),
+                                        units = self.controller_units)
             else:
                 position = self.get_actuator_value()
         if position.name != self._title:  # make sure the emitted DataActuator has the name of the real implementation
             #of the plugin
-            position = DataActuator(self._title, data=position.value())
+            position = DataActuator(self._title, data=position.value(),
+                                    units = self.controller_units)
         self.move_done_signal.emit(position)
         self.move_is_done = True
 
@@ -493,31 +518,40 @@ class DAQ_Move_base(QObject):
             if self.ispolling:
                 self.poll_timer.start()
             else:
-                if self.data_actuator_type.name == 'float':
-                    self._current_value = DataActuator(data=self.get_actuator_value())
+                if self.data_actuator_type == DataActuatorType.float:
+                    self._current_value = DataActuator(data=self.get_actuator_value(),
+                                                       units=self.controller_units)
                 else:
                     self._current_value = self.get_actuator_value()
+                    if (not Unit(self.controller_units).is_compatible_with(
+                            Unit(self._current_value.units)) and
+                            self._current_value.units == ''):
+                        # this happens if the units have not been specified in
+                        # the plugin
+                        self._current_value.force_units(self.controller_units)
+
                 logger.debug(f'Current position: {self._current_value}')
                 self.move_done(self._current_value)
 
     def check_target_reached(self):
-        # if not isinstance(self._current_value, DataActuator):
-        #     self._current_value = DataActuator(data=self._current_value)
-        # if not isinstance(self._target_value, DataActuator):
-        #     self._target_value = DataActuator(data=self._target_value)
-
         logger.debug(f"epsilon value is {self.settings['epsilon']}")
         logger.debug(f"current_value value is {self._current_value}")
         logger.debug(f"target_value value is {self._target_value}")
 
-        if not (self._current_value - self._target_value).abs() < self.settings['epsilon']:
+        try:
+            epsilon_calculated = (self._current_value - self._target_value).abs()
+        except DataUnitError as e:
+            epsilon_calculated = abs(self._current_value.value() - self._target_value.value())
+            logger.warning(f'Unit issue when calculating epsilon, units are not the same between'
+                           f'target and current values')
+
+        if not epsilon_calculated < self.settings['epsilon']:
 
             logger.debug(f'Check move_is_done: {self.move_is_done}')
             if self.move_is_done:
                 self.emit_status(ThreadCommand('Move has been stopped', ))
                 logger.info('Move has been stopped')
             self.current_value = self.get_actuator_value()
-
             self.emit_value(self._current_value)
             logger.debug(f'Current value: {self._current_value}')
 
@@ -624,7 +658,7 @@ class DAQ_Move_TCP_server(DAQ_Move_base, TCPServer):
     """
     params_client = []  # parameters of a client grabber
     command_server = Signal(list)
-    data_actuator_type = DataActuatorType['DataActuator']
+    data_actuator_type = DataActuatorType.DataActuator
 
     message_list = ["Quit", "Status", "Done", "Server Closed", "Info", "Infos", "Info_xml", "move_abs",
                     'move_home', 'move_rel', 'get_actuator_value', 'stop_motion', 'position_is', 'move_done']

{pymodaq-4.3.4 → pymodaq-4.3.6}/src/pymodaq/control_modules/viewer_utility_classes.py

@@ -227,7 +227,7 @@ class DAQ_Viewer_base(QObject):
         """
         pass
 
-    def ini_detector_init(self, old_controller=None, new_controller=None):
+    def ini_detector_init(self, old_controller=None, new_controller=None, slave_controller=None):
         """Manage the Master/Slave controller issue
 
         First initialize the status dictionary
@@ -245,6 +245,8 @@ class DAQ_Viewer_base(QObject):
             The particular object that allow the communication with the hardware, in general a python wrapper around the
             hardware library. In case of Master it is the new instance of your plugin controller
         """
+        if old_controller is None and slave_controller is not None:
+            old_controller = slave_controller
         self.status.update(edict(info="", controller=None, initialized=False))
         if self.settings['controller_status'] == "Slave":
             if old_controller is None:

pymodaq-4.3.6/src/pymodaq/resources/VERSION

@@ -0,0 +1,2 @@
+version = '4.3.6'
+

{pymodaq-4.3.4 → pymodaq-4.3.6}/src/pymodaq/utils/data.py

@@ -633,6 +633,10 @@ class DataBase(DataLowLevel):
 
     @property
     def units(self):
+        """ Get/Set the object units
+
+        Setting to other units should retain the unit compatibility
+        """
         return self._units
 
     @units.setter
@@ -640,6 +644,10 @@ class DataBase(DataLowLevel):
         units = check_units(units)
         self.units_as(units, inplace=True)
 
+    def force_units(self, units: str):
+        """ Change immediately the units to whatever else. Use this with care!"""
+        self._units = units
+
     def units_as(self, units: str, inplace=True) -> 'DataBase':
         """ Set the object units to the new one (if possible)
 
@@ -2401,9 +2409,9 @@ 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

pymodaq-4.3.4/src/pymodaq/resources/VERSION

@@ -1,2 +0,0 @@
-version = '4.3.4'
-