pymodaq 4.3.7__py3-none-any.whl → 4.4.2__py3-none-any.whl

pymodaq/__init__.py

@@ -51,6 +51,7 @@ try:
     ureg.default_format = '~'
     Q_ = ureg.Quantity
     Unit = ureg.Unit
+    ureg.define('whatever = 1  = wr')  # defining whatever as a dimensionless quantity
     logger.info('')
     logger.info('')
 

pymodaq/control_modules/daq_move.py

@@ -23,7 +23,8 @@ 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, DataActuatorType
+from pymodaq.control_modules.move_utility_classes import (MoveCommand, DAQ_Move_base,
+                                                          DataActuatorType, check_units)
 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
@@ -32,7 +33,8 @@ from pymodaq.utils import config as config_mod
 from pymodaq.utils.exceptions import ActuatorError
 from pymodaq.utils.messenger import deprecation_msg
 from pymodaq.utils.h5modules import module_saving
-from pymodaq.utils.data import DataRaw, DataToExport, DataFromPlugins, DataActuator
+from pymodaq.utils.data import (DataRaw, DataToExport, DataFromPlugins, DataActuator, Unit,
+                                DataUnitError)
 from pymodaq.utils.h5modules.backends import Node
 from pymodaq.utils.parameter import ioxml, Parameter
 
@@ -161,11 +163,13 @@ class DAQ_Move(ParameterControlModule):
             self.stop_motion()
         elif cmd.command == 'move_abs':
             data_act: DataActuator = cmd.attribute
-            data_act.force_units(self.units)
+            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':
             data_act: DataActuator = cmd.attribute
-            data_act.force_units(self.units)
+            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()
@@ -591,7 +595,14 @@ 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)
+            if unit == '°':
+                # special cas as pint base unit for angles are radians
+                self.ui.set_unit_as_suffix(unit)
+            else:
+                # 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...
+                self.ui.set_unit_as_suffix(str(Q_(1, unit).to_base_units().units))
 
     def update_settings(self):
 
@@ -668,8 +679,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
@@ -692,9 +701,8 @@ class DAQ_Move_Hardware(QObject):
         """
         pos = self.hardware.get_actuator_value()
         if self.hardware.data_actuator_type == DataActuatorType.float:
-            return DataActuator(self._title, data=pos, units=self.units)
-        else:
-            return pos
+            pos = DataActuator(self._title, data=pos, units=self.hardware.axis_unit)
+        return pos
 
     def check_position(self):
         """Get the current position checking the hardware position (deprecated)
@@ -743,6 +751,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:
@@ -753,15 +763,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()
 
@@ -769,14 +777,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()
@@ -798,7 +806,6 @@ class DAQ_Move_Hardware(QObject):
 
         """
         self.hardware.move_is_done = False
-        self._target_value = 0
         self.hardware.move_home()
 
     @Slot(DataActuator)

pymodaq/control_modules/daq_move_ui.py

@@ -7,6 +7,7 @@ Created the 28/07/2022
 
 from typing import List
 import sys
+from pint.errors import DimensionalityError
 
 from qtpy import QtWidgets
 from qtpy.QtCore import Signal, Qt
@@ -65,12 +66,17 @@ class DAQ_Move_UI(ControlModuleUI):
 
         super().__init__(parent)
         self.title = title
+        self._unit = ''
         self.setup_ui()
 
         self.enable_move_buttons(False)
 
     def display_value(self, value: DataActuator):
-        self.current_value_sb.setValue(value.value())
+        try:
+            self.current_value_sb.setValue(value.value(self._unit))
+        except DimensionalityError as e:
+            value.force_units(self._unit)
+            self.current_value_sb.setValue(value.value())
 
     @property
     def actuator_init(self):
@@ -193,9 +199,9 @@ class DAQ_Move_UI(ControlModuleUI):
         self.main_ui.layout().addWidget(self.toolbar, 0, 0, 1, 2)
         self.main_ui.layout().addWidget(self.move_toolbar, 1, 0, 1, 2)
 
-        self.abs_value_sb = SpinBox(step=0.1, dec=True)
+        self.abs_value_sb = SpinBox(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
         self.abs_value_sb.setStyleSheet("background-color : lightgreen; color: black")
-        self.abs_value_sb_2 = SpinBox(step=0.1, dec=True)
+        self.abs_value_sb_2 = SpinBox(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
         self.abs_value_sb_2.setStyleSheet("background-color : lightcoral; color: black")
         self.move_toolbar.addWidget(self.abs_value_sb)
         self.move_toolbar.addWidget(self.abs_value_sb_2)
@@ -221,7 +227,7 @@ class DAQ_Move_UI(ControlModuleUI):
         self.control_ui.layout().addWidget(LabelWithFont('Abs. Value'), 0, 0)
         self.find_home_pb = PushButtonIcon('home2', 'Find Home')
         self.control_ui.layout().addWidget(self.find_home_pb, 0, 1)
-        self.abs_value_sb_bis = SpinBox(step=0.1, dec=True)
+        self.abs_value_sb_bis = SpinBox(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
         self.control_ui.layout().addWidget(self.abs_value_sb_bis, 1, 0)
         self.move_abs_pb = PushButtonIcon('Move', 'Set Abs.',
                                           tip='Set the value of the actuator to the set absolute value')
@@ -230,7 +236,7 @@ class DAQ_Move_UI(ControlModuleUI):
         self.move_rel_plus_pb = PushButtonIcon('MoveUp', 'Set Rel. (+)')
         self.control_ui.layout().addWidget(self.move_rel_plus_pb, 2, 1)
 
-        self.rel_value_sb = SpinBox(step=0.1, dec=True)
+        self.rel_value_sb = SpinBox(step=0.1, dec=True, siPrefix=config('actuator', 'siprefix'))
         self.control_ui.layout().addWidget(self.rel_value_sb, 3, 0)
         self.move_rel_minus_pb = PushButtonIcon('MoveDown', 'Set Rel. (-)')
         self.control_ui.layout().addWidget(self.move_rel_minus_pb, 3, 1)
@@ -252,6 +258,7 @@ class DAQ_Move_UI(ControlModuleUI):
 
     def set_unit_as_suffix(self, unit: str):
         """Will append the actuator units in the value display"""
+        self._unit = unit
         self.current_value_sb.setOpts(suffix=unit)
         self.abs_value_sb_bis.setOpts(suffix=unit)
         self.abs_value_sb.setOpts(suffix=unit)
@@ -328,12 +335,14 @@ class DAQ_Move_UI(ControlModuleUI):
 
     def emit_move_abs(self, spinbox):
         spinbox.editingFinished.emit()
-        self.command_sig.emit(ThreadCommand('move_abs', DataActuator(data=spinbox.value())))
+        self.command_sig.emit(ThreadCommand('move_abs', DataActuator(data=spinbox.value(),
+                                                                     units=self._unit)))
 
     def emit_move_rel(self, sign):
-        self.command_sig.emit(ThreadCommand('move_rel',
-                                            DataActuator(data=self.rel_value_sb.value() * (1 if sign == '+'
-                                                                                           else -1))))
+        self.command_sig.emit(ThreadCommand(
+            'move_rel',
+            DataActuator(data=self.rel_value_sb.value() * (1 if sign == '+' else -1),
+                         units=self._unit)))
 
     def close(self):
         self.graph_ui.close()

pymodaq/control_modules/move_utility_classes.py

@@ -1,6 +1,9 @@
+import numbers
+
 from time import perf_counter
 from typing import Union, List, Dict, TYPE_CHECKING, Optional
 from numbers import Number
+from collections.abc import Iterable
 
 from easydict import EasyDict as edict
 import numpy as np
@@ -30,13 +33,45 @@ logger = set_logger(get_module_name(__file__))
 config = configmod.Config()
 
 
+def check_units(dwa: DataActuator, units: str):
+    """ Check if dwa units is compatible with the units argument
+
+    If it is incompatible and has dimensionless units,  brute force change the dwa units to units,
+    otherwise raise a DataUnitError
+
+    Parameters
+    ----------
+    dwa: DataActuator
+    units: str
+
+    Returns
+    -------
+    DataActuator
+    """
+    if Unit(dwa.units).is_compatible_with(units):
+        return dwa
+    elif Unit(dwa.units).dimensionless:  # dimensionless
+        dwa.force_units(units)
+        return dwa
+    else:
+        raise DataUnitError(f'Units incompatibility between {dwa} and "{units}" units')
+
+
 class DataActuatorType(BaseEnum):
     """Enum for new or old style holding the value of the actuator"""
     float = 0
     DataActuator = 1
 
 
-def comon_parameters(epsilon=config('actuator', 'epsilon_default')):
+def comon_parameters(epsilon=config('actuator', 'epsilon_default'),
+                     epsilons=None):
+    if epsilons is not None:
+        epsilon=epsilons
+    if isinstance(epsilon, list):
+        epsilon=epsilon[0]
+    elif isinstance(epsilon, dict):
+        epsilon=epsilon[list[epsilon.keys()][0]]
+
     return [{'title': 'Units:', 'name': 'units', 'type': 'str', 'value': '', 'readonly': True},
             {'title': 'Epsilon:', 'name': 'epsilon', 'type': 'float',
              'value': epsilon,
@@ -79,32 +114,45 @@ class MoveCommand:
         self.value = value
 
 
-def comon_parameters_fun(is_multiaxes = False,
-                         axes_names = [],
+def comon_parameters_fun(is_multiaxes=False, axes_names=None,
                          axis_names: Union[List, Dict] = [],
-                         master = True,
-                         epsilon = config('actuator', 'epsilon_default')):
+                         master=True,
+                         epsilon: float = config('actuator', 'epsilon_default')):
+
     """Function returning the common and mandatory parameters that should be on the actuator plugin level
 
     Parameters
     ----------
-    is_multiaxes: bool
+    is_multiaxes: bool  # deprecated not need anymore
         If True, display the particular settings to define which axis the controller is driving
-    axis_names: list of str
+    axes_names: deprecated, use axis_names
+    axis_names: list of str or dictionnary of string as key and integer as value
         The string identifier of every axis the controller can drive
     master: bool
         If True consider this plugin has to init the controller, otherwise use an already initialized instance
+    epsilon: float
+        deprecated (< 5.0.0) no more used here
+
     """
-    if axis_names == [] and len(axes_names) != 0:
+    if axes_names is not None and len(axis_names) == 0:
+        if len(axes_names) == 0:
+            axes_names = ['']
         axis_names = axes_names
 
+    is_multiaxes = len(axis_names) > 1
+    if isinstance(axis_names, list):
+        axis_name = axis_names[0]
+    elif isinstance(axis_names, dict):
+        axis_name = axis_names[list(axis_names.keys())[0]]
     params = [
-                 {'title': 'MultiAxes:', 'name': 'multiaxes', 'type': 'group', 'visible': is_multiaxes, 'children': [
-                     {'title': 'is Multiaxes:', 'name': 'ismultiaxes', 'type': 'bool', 'value': is_multiaxes,
-                      'default': False},
+                 {'title': 'MultiAxes:', 'name': 'multiaxes', 'type': 'group',
+                  'visible': is_multiaxes, 'children': [
+                     {'title': 'is Multiaxes:', 'name': 'ismultiaxes', 'type': 'bool',
+                      'value': is_multiaxes,  'default': False},
                      {'title': 'Status:', 'name': 'multi_status', 'type': 'list',
                       'value': 'Master' if master else 'Slave', 'limits': ['Master', 'Slave']},
-                     {'title': 'Axis:', 'name': 'axis', 'type': 'list', 'limits': axis_names},
+                     {'title': 'Axis:', 'name': 'axis', 'type': 'list', 'limits': axis_names,
+                      'value': axis_name},
                  ]},
              ] + comon_parameters(epsilon)
     return params
@@ -204,10 +252,16 @@ class DAQ_Move_base(QObject):
 
     move_done_signal = Signal(DataActuator)
     is_multiaxes = False
-    stage_names = []
+    stage_names = []  # deprecated
+
+    _axis_names: Union[list, Dict[str, int]] = None
+    _controller_units: Union[str, List[str], Dict[str, int]] = ''
+    _epsilons: Union[float, List[float], Dict[str, float]] = None
+    _epsilon = 1.0  # deprecated
+
+
     params = []
-    _controller_units = ''
-    _epsilon = 1
+
     data_actuator_type = DataActuatorType.float
     data_shape = (1, )  # expected shape of the underlying actuator's value (in general a float so shape = (1, ))
 
@@ -237,18 +291,19 @@ class DAQ_Move_base(QObject):
         else:
             self._title = "myactuator"
 
-        if isinstance(self._controller_units, list):
-            # for backcompatibility
-            # in case an actuator has multiple units properly handled in future version of pymodaq
-            self._controller_units = self._controller_units[self.axis_names.index(self.axis_name)]
+        self._axis_units: Union[Dict[str, str], List[str]] = None
+        self.axis_units = self._controller_units
+        if self._epsilons is None:
+            self._epsilons = self._epsilon
+        self.epsilons = self._epsilons
+        self.axis_name = self.axis_name  # to trigger some actions on units and epsilons
 
         self._current_value = DataActuator(self._title,
                                            data=[np.zeros(self.data_shape, dtype=float)],
-                                           units=self.controller_units)
+                                           units=self.axis_unit)
         self._target_value = DataActuator(self._title,
                                           data=[np.zeros(self.data_shape, dtype=float)],
-                                          units=self.controller_units)
-        self.controller_units = self._controller_units
+                                          units=self.axis_unit)
 
         self.poll_timer = QTimer()
         self.poll_timer.setInterval(config('actuator', 'polling_interval_ms'))
@@ -258,7 +313,108 @@ class DAQ_Move_base(QObject):
         self.ini_attributes()
 
     @property
-    def axis_name(self) -> Union[str, object]:
+    def axis_unit(self) -> str:
+        """ Get/set the unit of the currently chosen axis
+
+        Will update the printed controller unit in the UI
+
+        New in 4.4.0
+        """
+        return self.axis_units[self.axis_index_key]
+
+    @axis_unit.setter
+    def axis_unit(self, unit: str):
+        self.axis_units[self.axis_index_key] = unit
+        self.settings.child('units').setValue(unit)
+        self.emit_status(ThreadCommand('units', unit))
+
+    @property
+    def axis_units(self) -> Union[List[str], Dict[str, str]]:
+        """ Get/Set the units for each axis of the controller
+
+        New in 4.4.0
+        """
+        return self._axis_units
+
+    @axis_units.setter
+    def axis_units(self, units: Union[str, List[str], Dict[str, str]]):
+        if isinstance(units, str):
+            if isinstance(self.axis_names, list):
+                units_tmp = [units for _ in range(len(self.axis_names))]
+            else:
+                units_tmp = {}
+                for key in self.axis_names:
+                    units_tmp[key] = units
+        else:
+            if not isinstance(units, type(self.axis_names)):
+                raise TypeError('units should be defined just like axis_names: a str, list of string or'
+                                'dict of string')
+            if len(units) != len(self.axis_names):
+                raise ValueError('Units should be defined either as a single str or a list/dict with'
+                                 'a str defined for each axis')
+            units_tmp = units
+        self._axis_units = units_tmp
+
+    @property
+    def epsilon(self) -> float:
+        """ Get/Set the epsilon of the currently chosen axis
+
+        New in 4.4.0
+        """
+        return self.epsilons[self.axis_index_key]
+
+    @epsilon.setter
+    def epsilon(self, eps: float):
+        self.epsilons[self.axis_index_key] = eps
+
+    @property
+    def epsilons(self) -> Union[List[float], Dict[str, float]]:
+        """ Get/Set the epsilon for each axis of the controller
+
+        New in 4.4.0
+        """
+        return self._epsilons
+
+    @epsilons.setter
+    def epsilons(self, epsilons: Union[float, List[float], Dict[str, float]]):
+        if isinstance(epsilons, numbers.Number):
+            if isinstance(self.axis_names, list):
+                epsilons_tmp = [epsilons for _ in range(len(self.axis_names))]
+            else:
+                epsilons_tmp = {}
+                for key in self.axis_names:
+                    epsilons_tmp[key] = epsilons
+        else:
+            if not isinstance(epsilons, type(self.axis_names)):
+                raise TypeError('units should be defined just like axis_names: a float, list of '
+                                'float or dict of float')
+            if len(epsilons) != len(self.axis_names):
+                raise ValueError('epsilons should be defined either as a single float or a '
+                                 'list/dict with'
+                                 'a float defined for each axis')
+            epsilons_tmp = epsilons
+        self._epsilons = epsilons_tmp
+
+    @property
+    def controller_units(self):
+        """ Get/Set the units of the currently chosen axis of the controller
+
+        Deprecated with pymodaq >= 4.4.0
+
+        The property controller_units is deprecated please use the axis_unit property
+        """
+        deprecation_msg('The property controller_units is deprecated please use the'
+                        'axis_unit property.')
+        return self.axis_unit
+
+    @controller_units.setter
+    def controller_units(self, units: str = ''):
+        deprecation_msg('The property controller_units is deprecated please use the'
+                        'axis_unit property.')
+        self._axis_units[self.axis_index_key] = units
+
+    @property
+    def axis_name(self) -> Union[str]:
         """Get/Set the current axis using its string identifier"""
         limits = self.settings.child('multiaxes', 'axis').opts['limits']
         if isinstance(limits, list):
@@ -275,6 +431,9 @@ class DAQ_Move_base(QObject):
             elif isinstance(limits, dict):
                 self.settings.child('multiaxes', 'axis').setValue(limits[name])
             QtWidgets.QApplication.processEvents()
+            self.axis_unit = self.axis_unit
+            self.settings.child('epsilon').setValue(self.epsilon)
+
 
     @property
     def axis_names(self) -> Union[List, Dict]:
@@ -292,9 +451,29 @@ class DAQ_Move_base(QObject):
         QtWidgets.QApplication.processEvents()
 
     @property
-    def axis_value(self) -> object:
-        """Get the current value selected from the current axis"""
-        return self.settings['multiaxes', 'axis']
+    def axis_value(self) -> int:
+        """Get the current value selected from the current axis
+
+        In case axis_names is a list, return the element of the list: self.axis_name
+        In case axis_names is a dict, return the value of the dict self.axis_names[self.axis_name]
+        """
+        if isinstance(self.axis_names, list):
+            return self.axis_name
+        else:
+            return self.axis_names[self.axis_name]
+
+    @property
+    def axis_index_key(self) -> Union[int, str]:
+        """ Get the current index or key correspondingto the current axis
+
+        In case axis_names is a list, return the index wihtin the list
+        In case axis_names is a dict, return the key of the dict self.axis_name
+
+        """
+        if isinstance(self.axis_names, list):
+            return self.axis_names.index(self.axis_name)
+        else:
+            return self.axis_name
 
     def ini_attributes(self):
         """ To be subclassed, in order to init specific attributes needed by the real implementation"""
@@ -334,40 +513,40 @@ class DAQ_Move_base(QObject):
 
     @property
     def current_value(self):
-        if self.data_actuator_type.name == 'float':
+        if self.data_actuator_type == self.data_actuator_type.float:
             return self._current_value.value()
         else:
             return self._current_value
 
     @current_value.setter
     def current_value(self, value: Union[float, DataActuator]):
-        if not isinstance(value, DataActuator):
+        if isinstance(value, numbers.Number):
             self._current_value = DataActuator(self._title, data=value,
-                                               units=self.controller_units)
+                                               units=self.axis_unit)
         else:
-            if (not Unit(self.controller_units).is_compatible_with(
+            if (not Unit(self.axis_unit).is_compatible_with(
                     Unit(value.units)) and
                     value.units == ''):
-                value.force_units(self.controller_units)
+                value.force_units(self.axis_unit)
             self._current_value = value
 
     @property
     def target_value(self):
-        if self.data_actuator_type.name == 'float':
+        if self.data_actuator_type.name == self.data_actuator_type.float:
             return self._target_value.value()
         else:
             return self._target_value
 
     @target_value.setter
-    def target_value(self, value: Union[float, DataActuator]):
-        if not isinstance(value, DataActuator):
+    def target_value(self, value: Union[numbers.Number, DataActuator]):
+        if isinstance(value, numbers.Number):
             self._target_value = DataActuator(self._title, data=value,
-                                              units=self.controller_units)
+                                              units=self.axis_unit)
         else:
-            if (not Unit(self.controller_units).is_compatible_with(
+            if (not Unit(self.axis_unit).is_compatible_with(
                     Unit(value.units)) and
                     value.units == ''):
-                value.force_units(self.controller_units)
+                value.force_units(self.axis_unit)
             self._target_value = value
 
     @property
@@ -396,19 +575,6 @@ class DAQ_Move_base(QObject):
         """
         return self.settings['multiaxes', 'multi_status'] == 'Master'
 
-    @property
-    def controller_units(self):
-        """ Get/Set the units of this plugin"""
-        return self._controller_units
-
-    @controller_units.setter
-    def controller_units(self, units: str = ''):
-        self._controller_units = units
-        try:
-            self.settings.child('units').setValue(units)
-            self.emit_status(ThreadCommand('units', units))
-        except Exception:
-            pass
 
     @property
     def ispolling(self):
@@ -428,12 +594,12 @@ class DAQ_Move_base(QObject):
             if position > self.settings.child('bounds', 'max_bound').value():
                 position = DataActuator(self._title,
                                         data=self.settings.child('bounds', 'max_bound').value(),
-                                        units = self.controller_units)
+                                        units=self.axis_unit)
                 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(),
-                                        units=self.controller_units
+                                        units=self.axis_unit
                                         )
                 self.emit_status(ThreadCommand('outofbounds', []))
         return position
@@ -502,13 +668,13 @@ 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(),
-                                        units = self.controller_units)
+                                        units=self.axis_unit)
             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(),
-                                    units = self.controller_units)
+                                    units=self.axis_unit)
         self.move_done_signal.emit(position)
         self.move_is_done = True
 
@@ -526,32 +692,59 @@ class DAQ_Move_base(QObject):
             else:
                 if self.data_actuator_type == DataActuatorType.float:
                     self._current_value = DataActuator(data=self.get_actuator_value(),
-                                                       units=self.controller_units)
+                                                       units=self.axis_unit)
                 else:
                     self._current_value = self.get_actuator_value()
-                    if (not Unit(self.controller_units).is_compatible_with(
+                    if (not Unit(self.axis_unit).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)
+                        self._current_value.force_units(self.axis_unit)
 
                 logger.debug(f'Current position: {self._current_value}')
                 self.move_done(self._current_value)
 
-    def check_target_reached(self):
-        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}")
+    def _condition_to_reach_target(self) -> bool:
+        """ Implement the condition for exiting the polling mechanism and specifying that the
+        target value has been reached
+
+        Returns
+        -------
+        bool: if True, PyMoDAQ considers the target value has been reached at epsilon
 
+        See Also
+        --------
+        user_condition_to_reach_target
+        """
         try:
-            epsilon_calculated = (self._current_value - self._target_value).abs()
+            epsilon_calculated = (
+                    self._current_value - self._target_value).abs().value(self.axis_unit)
         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'
+            logger.warning(f'Unit issue when calculating epsilon, units are not compatible between'
                            f'target and current values')
 
-        if not epsilon_calculated < self.settings['epsilon']:
+        return (epsilon_calculated < self.epsilon) and self.user_condition_to_reach_target()
+
+    def user_condition_to_reach_target(self) -> bool:
+        """ Implement a user defined condition for exiting the polling mechanism and specifying
+        that the target value has been reached (on top of the existing epsilon mechanism)
+
+        Should be reimplemented in plugins to implement other conditions
+
+        Returns
+        -------
+        bool: if True, PyMoDAQ considers the target value has been reached
+        """
+        return True
+
+    def check_target_reached(self):
+        logger.debug(f"epsilon value is {self.epsilon}")
+        logger.debug(f"current_value value is {self._current_value}")
+        logger.debug(f"target_value value is {self._target_value}")
+
+        if not self._condition_to_reach_target():
 
             logger.debug(f'Check move_is_done: {self.move_is_done}')
             if self.move_is_done:
@@ -647,6 +840,11 @@ class DAQ_Move_base(QObject):
             self.commit_common_settings(param)
             self.commit_settings(param)
 
+            if param.name() == 'axis':
+                self.axis_name = param.value()
+            elif param.name() == 'epsilon':
+                self.epsilon = param.value()
+
 
 class DAQ_Move_TCP_server(DAQ_Move_base, TCPServer):
     """

pymodaq/examples/parameter_ex.py

@@ -22,6 +22,8 @@ class ParameterEx(ParameterManager):
         {'title': 'Numbers:', 'name': 'numbers', 'type': 'group', 'children': [
             {'title': 'Standard float', 'name': 'afloat', 'type': 'float', 'value': 20., 'min': 1.,
              'tip': 'displays this text as a tooltip'},
+            {'title': 'Standard float with Si prefix', 'name': 'afloatprefix', 'type': 'float', 'value': 20.,
+             'tip': 'displays this text as a tooltip', 'siPrefix': True, 'suffix': 'V'},
             {'title': 'Linear Slide float', 'name': 'linearslidefloat', 'type': 'slide', 'value': 50, 'default': 50,
              'min': 0,
              'max': 123, 'subtype': 'linear'},

pymodaq/resources/VERSION

@@ -1,2 +1,2 @@
-version = '4.3.7'
+version = '4.4.2'
 

pymodaq/utils/config.py

@@ -20,7 +20,7 @@ except:
     USER = 'unknown_user'
 
 CONFIG_BASE_PATH = Path(environ['PROGRAMDATA']) if sys.platform == 'win32' else \
-    Path('/Library/Application Support') if sys.platform == 'darwin' else Path('/etc')
+    Path('Library/Application Support') if sys.platform == 'darwin' else Path('/etc')
 
 
 KeyType = TypeVar('KeyType')

pymodaq/utils/data.py

@@ -2413,21 +2413,48 @@ class DataActuator(DataRaw):
         else:
             return f'<{self.__class__.__name__} ({self.shape} {self.units})>'
 
-    def value(self) -> float:
+    def value(self, units: str = None) -> 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"""
+        holds only a float otherwise returns a mean of the underlying data
+
+        Parameters
+        ----------
+
+        units: str
+            if unit is compatible with self.units, convert the data to these new units before
+            getting the value
+
+
+        """
         if self.length == 1 and self.size == 1:
-            return float(self.data[0][0])
+            if units is not None:
+                data = Q_(float(self.data[0][0]), self.units)
+                return data.m_as(units)
+            else:
+                return float(self.data[0][0])
         else:
-            return float(np.mean(self.data))
+            if units is not None:
+                data = Q_(float(np.mean(self.data[0])), self.units)
+                return data.m_as(units)
+            else:
+                return float(np.mean(self.data[0]))
 
-    def values(self) -> List[float]:
+    def values(self, units: str = None) -> 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]
+            if units is not None:
+                return [float(Q_(data_array[0], self.units).m_as(units))
+                        for data_array in self.data]
+            else:
+                return [float(data_array[0])
+                        for data_array in self.data]
         else:
-            return [float(np.mean(data_array)) for data_array in self.data]
+            if units is not None:
+                return [float(Q_(np.mean(data_array), self.units).m_as(units))
+                        for data_array in self.data]
+            else:
+                return [float(np.mean(data_array)) for data_array in self.data]
 
 
 class DataFromPlugins(DataRaw):

pymodaq/utils/gui_utils/loader_utils.py

@@ -12,7 +12,7 @@ def load_dashboard_with_preset(preset_name: str, extension_name: str):
     area = DockArea()
     win.setCentralWidget(area)
     win.resize(1000, 500)
-    win.setWindowTitle('PyMoDAQ Dashboard')
+    win.setWindowTitle('extension_name')
     win.show()
 
     # win.setVisible(False)

pymodaq/utils/tcp_ip/serializer.py

@@ -420,6 +420,7 @@ class Serializer:
         * serialize the string type: 'DataWithAxes'
         * serialize the timestamp: float
         * serialize the name
+        * serialize the units
         * serialize the source enum as a string
         * serialize the dim enum as a string
         * serialize the distribution enum as a string
@@ -439,6 +440,7 @@ class Serializer:
         bytes_string += self.object_type_serialization(dwa)
         bytes_string += self.scalar_serialization(dwa.timestamp)
         bytes_string += self.string_serialization(dwa.name)
+        bytes_string += self.string_serialization(dwa.units)
         bytes_string += self.string_serialization(dwa.source.name)
         bytes_string += self.string_serialization(dwa.dim.name)
         bytes_string += self.string_serialization(dwa.distribution.name)
@@ -731,9 +733,11 @@ class DeSerializer:
         """
         class_name = self.string_deserialization()
         if class_name not in DwaType.names():
-            raise TypeError(f'Attempting to deserialize a DataWithAxes flavor but got the bytes for a {class_name}')
+            raise TypeError(f'Attempting to deserialize a DataWithAxes '
+                            f'flavor but got the bytes for a {class_name}')
         timestamp = self.scalar_deserialization()
         dwa = getattr(data_mod, class_name)(self.string_deserialization(),
+                                            units=self.string_deserialization(),
                                             source=self.string_deserialization(),
                                             dim=self.string_deserialization(),
                                             distribution=self.string_deserialization(),

{pymodaq-4.3.7.dist-info → pymodaq-4.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymodaq
-Version: 4.3.7
+Version: 4.4.2
 Summary: Modular Data Acquisition with Python
 Project-URL: Homepage, http://pymodaq.cnrs.fr
 Project-URL: Source, https://github.com/PyMoDAQ/PyMoDAQ
@@ -77,7 +77,7 @@ PyMoDAQ
    :target: https://pymodaq.readthedocs.io/en/stable/?badge=latest
    :alt: Documentation Status
 
-.. image:: https://codecov.io/gh/PyMoDAQ/PyMoDAQ/branch/pymodaq-dev/graph/badge.svg?token=IQNJRCQDM2
+.. image:: https://codecov.io/gh/PyMoDAQ/PyMoDAQ/branch/4.4.x/graph/badge.svg?token=IQNJRCQDM2
     :target: https://codecov.io/gh/PyMoDAQ/PyMoDAQ
 
 ====== ========== ======= ======
@@ -93,25 +93,25 @@ Python Qt Backend OS      Passed
 ====== ========== ======= ======
 
 
-.. |38Qt5| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp38pyqt5.yml/badge.svg?branch=4.3.x_dev
+.. |38Qt5| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp38pyqt5.yml/badge.svg?branch=4.4.x
     :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp38pyqt5.yml
 
-.. |39Qt5| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp39pyqt5.yml/badge.svg?branch=4.3.x_dev
+.. |39Qt5| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp39pyqt5.yml/badge.svg?branch=4.4.x
     :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp39pyqt5.yml
 
-.. |310Qt5| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp310pyqt5.yml/badge.svg?branch=4.3.x_dev
+.. |310Qt5| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp310pyqt5.yml/badge.svg?branch=4.4.x
     :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp310pyqt5.yml
 
-.. |311Qt5| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp311pyqt5.yml/badge.svg?branch=4.3.x_dev
+.. |311Qt5| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp311pyqt5.yml/badge.svg?branch=4.4.x
     :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp311pyqt5.yml
 
-.. |38Qt5win| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp38pyqt5_win.yml/badge.svg?branch=4.3.x_dev
+.. |38Qt5win| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp38pyqt5_win.yml/badge.svg?branch=4.4.x
     :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp38pyqt5_win.yml
 
-.. |38pyside| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp38pyside2.yml/badge.svg?branch=4.3.x_dev
+.. |38pyside| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp38pyside2.yml/badge.svg?branch=4.4.x
     :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp38pyside2.yml
 
-.. |39Qt6| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp39pyqt6.yml/badge.svg?branch=4.3.x_dev
+.. |39Qt6| image:: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp39pyqt6.yml/badge.svg?branch=4.4.x
     :target: https://github.com/PyMoDAQ/PyMoDAQ/actions/workflows/Testp39pyqt6.yml
 
 

{pymodaq-4.3.7.dist-info → pymodaq-4.4.2.dist-info}/RECORD

@@ -1,14 +1,14 @@
-pymodaq/__init__.py,sha256=boHjxPnKEAQUmOHKbnxlI8DHP1eM5IKSrrnd1EqkvHg,4295
+pymodaq/__init__.py,sha256=e4pcKgxrhCVtCuq3t-gcfkwCWtV72K6jhPa-0zAtRfs,4382
 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=dq29GbNf-8BpquR3z8ZuqvKaP-0p14LLrAAVg75pIis,36590
-pymodaq/control_modules/daq_move_ui.py,sha256=euA8_utFfiscd9ahZxRTqqTiCSrNB4CKCLqgdbUKSlI,15307
+pymodaq/control_modules/daq_move.py,sha256=L4lW_VfdBKmrlpLkKwbNitDeLHbFWk6Lbq4T5k-6xiM,37323
+pymodaq/control_modules/daq_move_ui.py,sha256=IbqNAErwXGjKUbYEptvZUz3J8MapNBFIbQnUf9nQrMw,15753
 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=g_Q8eOPetwFuVbQfWTk4gX5XMsJoTvf_a7vdOrR5DoU,35731
+pymodaq/control_modules/move_utility_classes.py,sha256=WwZku-xFsyqun25IG9570_OU5x1frA9rIrxVu6XJKIk,42599
 pymodaq/control_modules/utils.py,sha256=5YdSwq_lFJm7IalYWe_Hn1U4LUoUmo1gedvV9UguU0Y,20016
 pymodaq/control_modules/viewer_utility_classes.py,sha256=OHxwue1t3z2AXyeqNjnwPT2pMc8yXhnqyiWc9IdCI2c,26841
 pymodaq/examples/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -16,7 +16,7 @@ pymodaq/examples/custom_app.py,sha256=2wQR0hlPWjZrWK0abNF6ASv8iQyJqRn2CKnBa_nAgN
 pymodaq/examples/custom_viewer.py,sha256=nUj5n6l7DSyh-qaXboNBfXKa9mAiXrHSiOcuFL1ayRE,4814
 pymodaq/examples/function_plotter.py,sha256=T-VT0Rd3jHP9GcR2h6Nao6lwZE06P8zWUbOlz8b8Rxk,6104
 pymodaq/examples/nonlinearscanner.py,sha256=x0R2_FP0YnuOCCAmYRiAiZ1jfUdRxu5RqIYLyGQMZ0U,3790
-pymodaq/examples/parameter_ex.py,sha256=AVzs9aeZFe3U5SkFvC9VZuRZPoB-UMCxYYEnFH6if40,8357
+pymodaq/examples/parameter_ex.py,sha256=NmFUvUByNtm3j4leN_MkufQsKlNU8Rx5lmpsVG58IIM,8556
 pymodaq/examples/preset_MockCamera.xml,sha256=quQlMsX6YSoqqc9_9Y-9zu3TDM6Xvnuc2JSWwg9f948,15774
 pymodaq/examples/tcp_client.py,sha256=FSdPlb3R_rxxNIqPqHVU8PxJzNZeFk_93l4TqsB5SnA,2584
 pymodaq/examples/Labview_TCP_Client/DAQ_TCP_Client.aliases,sha256=t0eKH9Uq_AMk4wQ-6Pm5mKUjGcCvfT9GtvMsvDhkCUk,47
@@ -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=fP37ke9RfdHBjYyyxWc1kXW6-Gg-gr80uqzn0qTdrE8,19
+pymodaq/resources/VERSION,sha256=u7UAa-_KS1Q9ODCq7-42m4PKdNLnm3M_qQLvikeM9Hc,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
@@ -308,10 +308,10 @@ pymodaq/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymodaq/utils/array_manipulation.py,sha256=uMdiVVR2mU7j6Z4DKL5VGhUPqiWvFX2YK7RLMGdLyC8,10415
 pymodaq/utils/calibration_camera.py,sha256=d3aAu0izXOdeLs-vyBaFfBuvyDGT3O-SreTuyd0Kvs4,8921
 pymodaq/utils/chrono_timer.py,sha256=rwX8apS8B-IKhA0Cp2H9tLz0BRN7G3Pg5ptozvd3MKM,7244
-pymodaq/utils/config.py,sha256=u-Q4af-tgXG7h8YitMGSPkigDxGoOYSEMHERQCF9mAM,16203
+pymodaq/utils/config.py,sha256=0QqoBJC4ECuIeh1UsvUQqhxkKl7Vfgi4iERp-6qNWAc,16202
 pymodaq/utils/conftests.py,sha256=3Ak8WEpa3EhAp73Yb1LLq8YFONhPqiL7gG9eSDIoTNc,58
 pymodaq/utils/daq_utils.py,sha256=0jTrbT0aaZr3KaTgeDicmK9FbVnu3iaWBmNHnNJpr3A,28050
-pymodaq/utils/data.py,sha256=QPPFs57Eu1cEvF_QYJamjrPmickBVgsggg_bSkbd0P0,110621
+pymodaq/utils/data.py,sha256=V4F_H-sUPmCwrcNDuF7JxzcJtnOlQX7fChSoyXdd6ng,111572
 pymodaq/utils/enums.py,sha256=wpRipioUJkKcEfoaY2NrDQ2WhGxZTZiZoJty5f2Ljpc,2236
 pymodaq/utils/exceptions.py,sha256=wLO6VlofzfwWkOOWMN2B-3NEWMfpgygyeEdakIx_rAs,668
 pymodaq/utils/factory.py,sha256=QLqAPFnTZ93eUpmAAIr7kESDk2enD57RNSuFUsjxE4E,2311
@@ -333,7 +333,7 @@ pymodaq/utils/gui_utils/dock.py,sha256=6AcxC9HqM45bt20vJgP6QgGAhkW8mynuOuWhL7gep
 pymodaq/utils/gui_utils/file_io.py,sha256=mJI_30p986rLZk44FsPjesMazE1tq7HEFLenW-dnmOI,3367
 pymodaq/utils/gui_utils/layout.py,sha256=6oczLLGwwEN4EQ8yUDnz0-4Ue2wlyCRklKsVD1GNcz8,1099
 pymodaq/utils/gui_utils/list_picker.py,sha256=ddYnRTlRlgwdJSy0Q98IzYWHzIf2GS6ABl8XSS9kVXM,1190
-pymodaq/utils/gui_utils/loader_utils.py,sha256=7sfAvktORgF1DAcYCHsWrl57koaO8v4D4UCqXgUPxbU,1301
+pymodaq/utils/gui_utils/loader_utils.py,sha256=Gg0d31fjkqDq3l1WuRMbLzKiKPOIYdbUrcfGOgoXRk0,1298
 pymodaq/utils/gui_utils/utils.py,sha256=aPxFCnG4skDp-0UuhAudq6BPZnEXoAf6FOEJyrhUjx0,6089
 pymodaq/utils/gui_utils/widgets/__init__.py,sha256=LThGzmbFKbp2FtTTF_L7pHjyBzfB7F_bhMF4rPTwrUY,195
 pymodaq/utils/gui_utils/widgets/label.py,sha256=C2MU8i_Yy_oVRW7yal_ghB1Y5Bj_a9o8IFZWW3br-KM,600
@@ -436,10 +436,10 @@ pymodaq/utils/svg/svg_view.py,sha256=bmXpDqnw9S-Bp3F8Hi_oeYB5Y9gebiCNsQWVJzCq-PA
 pymodaq/utils/svg/svg_viewer2D.py,sha256=LTJ3Ulb5zWXdRPr7vqcWumbpq7ZctzrYUMtD5QV3x60,1523
 pymodaq/utils/tcp_ip/__init__.py,sha256=1e_EK0AgvdoLAD_CSGGEaITZdy6OWCO7ih9IAIp7HT4,81
 pymodaq/utils/tcp_ip/mysocket.py,sha256=StAWj8dzHeMnbLj68Sel81uWFy-YkKVNRnVf7gXrESI,3452
-pymodaq/utils/tcp_ip/serializer.py,sha256=oTQ24JNln_vRX4YADitTYiJplwFIdsta1ZDp6TOGMCA,27562
+pymodaq/utils/tcp_ip/serializer.py,sha256=htVQCE4saRBMeIcseEyxTt5G58A341m6OGkaJUA34Wk,27766
 pymodaq/utils/tcp_ip/tcp_server_client.py,sha256=xIMTNgVW_rKK0yTi4FDNFLf85-Akb27Jz2LdrvOrP68,30660
-pymodaq-4.3.7.dist-info/METADATA,sha256=jrLMgm6DJyOZdZaK-32Cxe4h_-ikdS4vDVKW6e8ozRc,7657
-pymodaq-4.3.7.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-pymodaq-4.3.7.dist-info/entry_points.txt,sha256=RAzdYNjvUT28I2eiCKki_g2NzXq0woWxhev6lwzwRv8,348
-pymodaq-4.3.7.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
-pymodaq-4.3.7.dist-info/RECORD,,
+pymodaq-4.4.2.dist-info/METADATA,sha256=wc6QZZgW3pBAs85kQQ88JdPtJ8omKojHa1RDSgtuR3s,7623
+pymodaq-4.4.2.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+pymodaq-4.4.2.dist-info/entry_points.txt,sha256=RAzdYNjvUT28I2eiCKki_g2NzXq0woWxhev6lwzwRv8,348
+pymodaq-4.4.2.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
+pymodaq-4.4.2.dist-info/RECORD,,