pymodaq 4.3.3__py3-none-any.whl → 4.3.5__py3-none-any.whl

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/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()
@@ -328,8 +333,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 +352,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 +417,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 +492,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 +515,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 +655,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/extensions/utils.py

@@ -45,14 +45,18 @@ 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})
-
-            except Exception as e:  # pragma: no cover
-                logger.warning(f'Impossible to import the {pkg.value}.extensions.{mod} extension: '
+                    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: '
+                                       f'{str(e)}')
+            except Exception as e:
+                logger.warning(f'Impossible to import the {pkg.value} package: '
                                f'{str(e)}')
 
     return extension_import

pymodaq/resources/VERSION

@@ -1,2 +1,2 @@
-version = '4.3.3'
+version = '4.3.5'
 

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.3.dist-info → pymodaq-4.3.5.dist-info}/METADATA

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

{pymodaq-4.3.3.dist-info → pymodaq-4.3.5.dist-info}/RECORD

@@ -3,12 +3,12 @@ pymodaq/dashboard.py,sha256=4fbV92erom0yWwqPMtx3KW1q-d6QYflV-EhOZMg24a4,64476
 pymodaq/icon.ico,sha256=hOHHfNDENKphQvG1WDleSEYcHukneR2eRFJu8isIlD4,74359
 pymodaq/splash.png,sha256=ow8IECF3tPRUMA4tf2tMu1aRiMaxx91_Y2ckVxkrmF0,53114
 pymodaq/control_modules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pymodaq/control_modules/daq_move.py,sha256=-ipGtKrkeB_eaMfdDVHDFu86J5By_pHO8Z5axOkC_tY,35985
+pymodaq/control_modules/daq_move.py,sha256=dq29GbNf-8BpquR3z8ZuqvKaP-0p14LLrAAVg75pIis,36590
 pymodaq/control_modules/daq_move_ui.py,sha256=euA8_utFfiscd9ahZxRTqqTiCSrNB4CKCLqgdbUKSlI,15307
 pymodaq/control_modules/daq_viewer.py,sha256=5CYmdWHGE7sQApeMfdWNV3zbPyoxxYtzFlQ1PaEw4fI,57883
 pymodaq/control_modules/daq_viewer_ui.py,sha256=FWP3jdIOR9vTgYqNaaodteGZ3dwgQ1GdWKrOpOAuSrs,15693
 pymodaq/control_modules/mocks.py,sha256=hh_xSWp9g1UV3NAQVD9Ft9tNWfTsSvKU0OU0trgzP2w,1956
-pymodaq/control_modules/move_utility_classes.py,sha256=bdO0O8qMcU4siW879XU7AAhcTLZz1s7vH_paDAD5G-8,33544
+pymodaq/control_modules/move_utility_classes.py,sha256=84xsY5LJz-KEVaXpVK0rBUs6TAV1qQwm2UWxaNIfNAM,35339
 pymodaq/control_modules/utils.py,sha256=5YdSwq_lFJm7IalYWe_Hn1U4LUoUmo1gedvV9UguU0Y,20016
 pymodaq/control_modules/viewer_utility_classes.py,sha256=mhUNZCx0SzaZJtxuKBMDcW5BfCY7hGPowJyQtQquwNE,26704
 pymodaq/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -40,7 +40,7 @@ pymodaq/extensions/daq_logger.py,sha256=hEAb98fv1qJxcH9NPvaiLp1SPWkBVBwpujJhuyAi
 pymodaq/extensions/daq_scan.py,sha256=CGBPrhLRHPmFJunKQ1aK5RgToXemzNEPdYSHn7e36DE,49414
 pymodaq/extensions/daq_scan_ui.py,sha256=bYJaWBLQMl2Yu1PAxc-bCldh4keWXd6l12ttrHqExE0,10181
 pymodaq/extensions/h5browser.py,sha256=eQZ8YhPHdiBCyHIn1JJJLn7OgZsc1XlcETgqdafofZs,1140
-pymodaq/extensions/utils.py,sha256=3cF3-7hVxYY1xxi0Kz-ck_yHcWyO5gAFFghf8Zo01Z8,2026
+pymodaq/extensions/utils.py,sha256=sh4SxJx5_lGJ6aJE8p8VJ2zrptW8pyze73aT_52xOwQ,2255
 pymodaq/extensions/bayesian/__init__.py,sha256=QMV9tq8Axi6YjoGj4UguBO8Zvuh26r5s91bm6YU7Itk,55
 pymodaq/extensions/bayesian/bayesian_optimisation.py,sha256=zB6DoyHx6nsKHsl3G4T0Hsw8npl80gdEIwvNfx4DCrU,30033
 pymodaq/extensions/bayesian/utils.py,sha256=1m_NpYMr-Swg2ImtMvbh-XOxutkAVwc0M2BWeK_NMIg,15544
@@ -58,7 +58,7 @@ pymodaq/post_treatment/daq_measurement/daq_measurement_GUI.py,sha256=1u7hWDaiwsZ
 pymodaq/post_treatment/daq_measurement/daq_measurement_GUI.ui,sha256=PyzbCWPMkh5oIYYteZczXyWMeHKW9EJmM1QlzXhnyTk,7037
 pymodaq/post_treatment/daq_measurement/daq_measurement_main.py,sha256=CAKwcWMOD86aXB8mbdxOK7e8nZRos5d59FzDtqK1QoY,17093
 pymodaq/post_treatment/daq_measurement/process_from_QtDesigner_DAQ_Measurement_GUI.bat,sha256=e1tu2A67MS9fk3jhriF6saQgRxWIucIvNW92iWXFP6E,164
-pymodaq/resources/VERSION,sha256=h2mDwD22qdTOg_NB5mTHQmwKnwAsac6zW9EJQsTh1lQ,19
+pymodaq/resources/VERSION,sha256=0IjdCbIfZfg9UZFoqckqiyGBwq0UheKTOg6QR2i3-Xw,19
 pymodaq/resources/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymodaq/resources/config_template.toml,sha256=d3pofgIK5FxaRMELAI1qEsRcMD3GlYd87zZjDj9G9m0,3210
 pymodaq/resources/preset_default.xml,sha256=Dt8iWLwPPOPtcG00JCVP-mh-G7KC6B0YN8hd8RQdnNI,27256
@@ -311,7 +311,7 @@ pymodaq/utils/chrono_timer.py,sha256=rwX8apS8B-IKhA0Cp2H9tLz0BRN7G3Pg5ptozvd3MKM
 pymodaq/utils/config.py,sha256=u-Q4af-tgXG7h8YitMGSPkigDxGoOYSEMHERQCF9mAM,16203
 pymodaq/utils/conftests.py,sha256=3Ak8WEpa3EhAp73Yb1LLq8YFONhPqiL7gG9eSDIoTNc,58
 pymodaq/utils/daq_utils.py,sha256=0jTrbT0aaZr3KaTgeDicmK9FbVnu3iaWBmNHnNJpr3A,28050
-pymodaq/utils/data.py,sha256=7m48jht2GOerMNszM5Pwvv5bdYHa3uTPc8UI2YQPmJE,110327
+pymodaq/utils/data.py,sha256=QPPFs57Eu1cEvF_QYJamjrPmickBVgsggg_bSkbd0P0,110621
 pymodaq/utils/enums.py,sha256=wpRipioUJkKcEfoaY2NrDQ2WhGxZTZiZoJty5f2Ljpc,2236
 pymodaq/utils/exceptions.py,sha256=wLO6VlofzfwWkOOWMN2B-3NEWMfpgygyeEdakIx_rAs,668
 pymodaq/utils/factory.py,sha256=QLqAPFnTZ93eUpmAAIr7kESDk2enD57RNSuFUsjxE4E,2311
@@ -438,8 +438,8 @@ pymodaq/utils/tcp_ip/__init__.py,sha256=1e_EK0AgvdoLAD_CSGGEaITZdy6OWCO7ih9IAIp7
 pymodaq/utils/tcp_ip/mysocket.py,sha256=StAWj8dzHeMnbLj68Sel81uWFy-YkKVNRnVf7gXrESI,3452
 pymodaq/utils/tcp_ip/serializer.py,sha256=oTQ24JNln_vRX4YADitTYiJplwFIdsta1ZDp6TOGMCA,27562
 pymodaq/utils/tcp_ip/tcp_server_client.py,sha256=xIMTNgVW_rKK0yTi4FDNFLf85-Akb27Jz2LdrvOrP68,30660
-pymodaq-4.3.3.dist-info/METADATA,sha256=ZjjuzNivAsZ9brdqz0U2tfvQ-t4R6FqluEvXDNa7qpo,7657
-pymodaq-4.3.3.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-pymodaq-4.3.3.dist-info/entry_points.txt,sha256=RAzdYNjvUT28I2eiCKki_g2NzXq0woWxhev6lwzwRv8,348
-pymodaq-4.3.3.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
-pymodaq-4.3.3.dist-info/RECORD,,
+pymodaq-4.3.5.dist-info/METADATA,sha256=RXJPRnt6t5mgH-ipkC__L_ESRPaV2rT-SrtENNTWv7w,7657
+pymodaq-4.3.5.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+pymodaq-4.3.5.dist-info/entry_points.txt,sha256=RAzdYNjvUT28I2eiCKki_g2NzXq0woWxhev6lwzwRv8,348
+pymodaq-4.3.5.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
+pymodaq-4.3.5.dist-info/RECORD,,