pymodaq 4.4.4__py3-none-any.whl → 4.4.6__py3-none-any.whl

pymodaq/control_modules/daq_move.py

@@ -595,14 +595,33 @@ 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'):
-            if unit == '°' or unit == 'degree':
-                # special cas as pint base unit for angles are radians
-                self.ui.set_unit_as_suffix('°')
-            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_reduced_units().units))
+            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:
+            return 'W'
+        elif '°C' in unit or 'Celsius' in unit:
+            return '°C'
+        else:
+            return str(Q_(1, unit).to_base_units().units)
 
     def update_settings(self):
 

pymodaq/control_modules/move_utility_classes.py

@@ -25,6 +25,7 @@ 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
+from pint.errors import OffsetUnitCalculusError
 
 if TYPE_CHECKING:
     from pymodaq.control_modules.daq_move import DAQ_Move_Hardware
@@ -437,7 +438,8 @@ class DAQ_Move_base(QObject):
             QtWidgets.QApplication.processEvents()
             self.axis_unit = self.axis_unit
             self.settings.child('epsilon').setValue(self.epsilon)
-
+            if self.controller is not None:
+                self._current_value = self.get_actuator_value()
 
     @property
     def axis_names(self) -> Union[List, Dict]:
@@ -728,6 +730,13 @@ class DAQ_Move_base(QObject):
             epsilon_calculated = abs(self._current_value.value() - self._target_value.value())
             logger.warning(f'Unit issue when calculating epsilon, units are not compatible between'
                            f'target and current values')
+        except OffsetUnitCalculusError as e:
+            if '°C' in self.axis_unit or 'celcius' in self.axis_unit.lower():
+                epsilon_calculated = (
+                        self._current_value.to_base_units() -
+                        self._target_value.to_base_units()).abs().value()
+            else:
+                raise e
 
         return (epsilon_calculated < self.epsilon) and self.user_condition_to_reach_target()
 

pymodaq/examples/qt_less_standalone_module.py

@@ -0,0 +1,128 @@
+"""
+Example how to create an actuator or detector module, which does not require Qt, nor any GUI functionality.
+
+You can connect to this qtless module with a PyMoDAQ LECODirector module (the detector or actuator version, both are preinstalled),
+as if it were any pymodaq module.
+
+This example works best with an Actuator Director Module as it has fake movements, but does not return any detector value.
+In this example, the name is "qt_less" (defined in the final if clause), which you have to give as the "actor" argument to the Director module.
+
+Add any code in the methods defined below, for example instrument access and execute the file.
+For remote control, you need to start a Coordinator, as described for remote control via LECO.
+"""
+
+import logging
+from time import sleep
+from typing import List, Union
+
+from pyleco.utils.listener import Listener
+
+
+class QtLessModule:
+    """Some module doing things without Qt.
+    
+    You can run an instance of this class anywhere in your LECO network.
+    Then you can control this instance with a PyMoDAQ LECODirectorModule (in mock modules) as if it were a PyMoDAQ module.
+
+    Just add any logic you wish to the methods below.
+    """
+
+    def __init__(self, name: str, host: str = "localhost", **kwargs) -> None:
+        super().__init__()
+        self.listener = Listener(name=name, host=host, timeout=1, **kwargs)
+        self._fake_position = 0
+        self.start_listen()
+        self._stored = []
+
+    def start_listen(self) -> None:
+        """Start to listen on incoming commands."""
+        self.listener.start_listen()
+        self.communicator = self.listener.get_communicator()
+        self.register_rpc_methods()
+
+    def register_rpc_methods(self) -> None:
+        """Make the following methods available via LECO."""
+        register_rpc_method = self.communicator.register_rpc_method
+        register_rpc_method(self.set_info)
+        register_rpc_method(self.send_data)
+        register_rpc_method(self.move_abs)
+        register_rpc_method(self.move_rel)
+        register_rpc_method(self.move_home)
+        register_rpc_method(self.get_actuator_value)
+        register_rpc_method(self.stop_motion)
+        register_rpc_method(self.set_remote_name)
+
+    def stop_listen(self) -> None:
+        """Stop to listen on incoming commands."""
+        self.listener.stop_listen()
+
+    # smethods for being remote controlled
+    # these methods are executed and cannot talk to the controlling module directly.
+    # if you need to send a response (for example with a value) you have to store the information and
+    # send it after these methods have been executed.
+    def set_remote_name(self, name: str) -> None:
+        """Define what the name of the remote for answers is."""
+        self.remote_name = name
+
+    # generic commands
+    def set_info(self, path: List[str], param_dict_str: str) -> None:
+        print("set_info", path, param_dict_str)
+
+    # detector commands
+    def send_data(self, grabber_type: str = "") -> None:
+        print("send_data")
+
+    # actuator commands
+    def move_abs(self, position: Union[float, str]) -> None:
+        print("move_abs", position)
+        self._fake_position = float(position)
+
+    def move_rel(self, position: Union[float, str]) -> None:
+        print("move_rel", position)
+        self._fake_position += float(position)
+
+    def move_home(self) -> None:
+        self._fake_position = 0
+        print("move_home")
+
+    def get_actuator_value(self) -> None:
+        """Request that the actuator value is sent later on."""
+        # according to DAQ_Move, this supersedes "check_position"
+        print("get_actuator_value")
+        # send the actuator position after this method has finished execution.
+        # this method sends the result to the controlling control module.
+        self.send_later(
+            receiver=self.remote_name,
+            method="set_position",
+            position=self._fake_position,
+        )
+
+    def stop_motion(self,) -> None:
+        # not implemented in DAQ_Move!
+        print("stop_motion")
+
+    # end of methods for being remote controlled
+
+    def send_later(self, receiver, method, **kwargs):
+        """Store information to send it later."""
+        self._stored.append((receiver, method, kwargs))
+
+    def send_stored(self):
+        """Send messages stored for later sending."""
+        while self._stored:
+            receiver, method, kwargs = self._stored.pop()
+            self.communicator.ask_rpc(receiver=receiver, method=method, **kwargs)
+
+
+if __name__ == "__main__":
+    print("listening endlessly as 'qt_less'")
+    log = logging.getLogger()
+    log.addHandler(logging.StreamHandler())
+    # log.setLevel(logging.DEBUG)
+    m = QtLessModule("qt_less")
+    try:
+        while True:
+            sleep(0.1)
+            m.send_stored()
+    except KeyboardInterrupt:
+        m.stop_listen()

pymodaq/resources/VERSION

@@ -1,2 +1,2 @@
-version = '4.4.4'
+version = '4.4.6'
 

pymodaq/resources/setup_plugin.py

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

pymodaq/utils/data.py

@@ -648,6 +648,13 @@ class DataBase(DataLowLevel):
         """ Change immediately the units to whatever else. Use this with care!"""
         self._units = units
 
+    def to_base_units(self):
+        dwa = self.deepcopy()
+        data_quantities = [quantity.to_base_units() for quantity in self.quantities]
+        dwa.data = [quantity.magnitude for quantity in data_quantities]
+        dwa.force_units(str(data_quantities[0].units))
+        return dwa
+
     def units_as(self, units: str, inplace=True) -> 'DataBase':
         """ Set the object units to the new one (if possible)
 

pymodaq/utils/leco/daq_move_LECODirector.py

@@ -55,11 +55,14 @@ class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
                          params_state=params_state, **kwargs)
         self.register_rpc_methods((
             self.set_info,
+        ))
+        for method in (
             self.set_position,
             self.set_move_done,
             self.set_x_axis,
             self.set_y_axis,
-        ))
+        ):
+            self.listener.register_binary_rpc_method(method, accept_binary_input=True)
 
         # copied, I think it is good:
         self.settings.child('bounds').hide()
@@ -143,22 +146,29 @@ class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
         self.controller.stop_motion()
 
     # Methods accessible via remote calls
-    def _set_position_value(self, position: Union[str, float]) -> DataActuator:
-        if isinstance(position, str):
-            deserializer = DeSerializer.from_b64_string(position)
-            pos = deserializer.dwa_deserialization()
+    def _set_position_value(
+        self, position: Union[str, float, None], additional_payload=None
+    ) -> DataActuator:
+        if position:
+            if isinstance(position, str):
+                deserializer = DeSerializer.from_b64_string(position)
+                pos = deserializer.dwa_deserialization()
+            else:
+                pos = DataActuator(data=position)
+        elif additional_payload is not None:
+            pos = DeSerializer(additional_payload[0]).dwa_deserialization()
         else:
-            pos = DataActuator(data=position)
+            raise ValueError("No position given")
         pos = self.get_position_with_scaling(pos)  # type: ignore
         self._current_value = pos
         return pos
 
-    def set_position(self, position: Union[str, float]) -> None:
-        pos = self._set_position_value(position=position)
+    def set_position(self, position: Union[str, float, None], additional_payload=None) -> None:
+        pos = self._set_position_value(position=position, additional_payload=additional_payload)
         self.emit_status(ThreadCommand('get_actuator_value', [pos]))
 
-    def set_move_done(self, position: Union[str, float]) -> None:
-        pos = self._set_position_value(position=position)
+    def set_move_done(self, position: Union[str, float, None], additional_payload=None) -> None:
+        pos = self._set_position_value(position=position, additional_payload=additional_payload)
         self.emit_status(ThreadCommand('move_done', [pos]))
 
     def set_x_axis(self, data, label: str = "", units: str = "") -> None:

pymodaq/utils/leco/daq_xDviewer_LECODirector.py

@@ -1,5 +1,5 @@
-
-from typing import Union
+from __future__ import annotations
+from typing import Optional, Union
 
 from easydict import EasyDict as edict
 
@@ -37,8 +37,11 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
         self.register_rpc_methods((
             self.set_x_axis,
             self.set_y_axis,
-            self.set_data,
         ))
+        for method in (
+            self.set_data,
+        ):
+            self.listener.register_binary_rpc_method(method, accept_binary_input=True)
 
         self.client_type = "GRABBER"
         self.x_axis = None
@@ -150,7 +153,7 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
         self.y_axis = dict(data=data, label=label, units=units)
         self.emit_y_axis()
 
-    def set_data(self, data: Union[list, str]) -> None:
+    def set_data(self, data: Union[list, str, None], additional_payload: Optional[list[bytes]]=None) -> None:
         """
         Set the grabbed data signal.
 
@@ -160,10 +163,12 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
         """
         if isinstance(data, str):
             deserializer = DeSerializer.from_b64_string(data)
-            dte = deserializer.dte_deserialization()
-            self.dte_signal.emit(dte)
+        elif additional_payload is not None:
+            deserializer = DeSerializer(additional_payload[0])
         else:
             raise NotImplementedError("Not implemented to set a list of values.")
+        dte = deserializer.dte_deserialization()
+        self.dte_signal.emit(dte)
 
 
 if __name__ == '__main__':

pymodaq/utils/leco/pymodaq_listener.py

@@ -17,7 +17,7 @@ from qtpy.QtCore import QObject, Signal  # type: ignore
 from pymodaq.utils.daq_utils import ThreadCommand
 from pymodaq.utils.parameter import ioxml
 from pymodaq.utils.tcp_ip.serializer import DataWithAxes, SERIALIZABLE, DeSerializer
-from pymodaq.utils.leco.utils import serialize_object
+from pymodaq.utils.leco.utils import binary_serialization_to_kwargs
 
 
 class LECOClientCommands(StrEnum):
@@ -220,7 +220,7 @@ class ActorListener(PymodaqListener):
             self.communicator.ask_rpc(
                 receiver=self.remote_name,
                 method="set_data",
-                data=serialize_object(value),
+                **binary_serialization_to_kwargs(value),
             )
 
         elif command.command == 'send_info':
@@ -236,14 +236,14 @@ class ActorListener(PymodaqListener):
             value = command.attribute[0]  # type: ignore
             self.communicator.ask_rpc(receiver=self.remote_name,
                                       method="set_position",
-                                      position=serialize_object(value),
+                                      **binary_serialization_to_kwargs(value, data_key="position"),
                                       )
 
         elif command.command == LECOMoveCommands.MOVE_DONE:
             value = command.attribute[0]  # type: ignore
             self.communicator.ask_rpc(receiver=self.remote_name,
                                       method="set_move_done",
-                                      position=serialize_object(value),
+                                      **binary_serialization_to_kwargs(value, data_key="position"),
                                       )
 
         elif command.command == 'x_axis':
@@ -251,7 +251,7 @@ class ActorListener(PymodaqListener):
             if isinstance(value, SERIALIZABLE):
                 self.communicator.ask_rpc(receiver=self.remote_name,
                                           method="set_x_axis",
-                                          data=serialize_object(value),
+                                          **binary_serialization_to_kwargs(value),
                                           )
             elif isinstance(value, dict):
                 self.communicator.ask_rpc(receiver=self.remote_name, method="set_x_axis", **value)
@@ -263,7 +263,7 @@ class ActorListener(PymodaqListener):
             if isinstance(value, SERIALIZABLE):
                 self.communicator.ask_rpc(receiver=self.remote_name,
                                           method="set_y_axis",
-                                          data=serialize_object(value),
+                                          **binary_serialization_to_kwargs(value),
                                           )
             elif isinstance(value, dict):
                 self.communicator.ask_rpc(receiver=self.remote_name, method="set_y_axis", **value)

pymodaq/utils/leco/utils.py

@@ -1,6 +1,7 @@
+from __future__ import annotations
 import subprocess
 import sys
-from typing import Any, Union, get_args
+from typing import Any, Optional, Union, get_args
 
 # import also the DeSerializer for easier imports in dependents
 from pymodaq.utils.tcp_ip.serializer import SERIALIZABLE, Serializer, DeSerializer  # type: ignore  # noqa
@@ -23,6 +24,29 @@ def serialize_object(pymodaq_object: Union[SERIALIZABLE, Any]) -> Union[str, Any
                          "JSON serializable, nor via PyMoDAQ.")
 
 
+def binary_serialization(
+    pymodaq_object: Union[SERIALIZABLE, Any],
+) -> tuple[Optional[Any], Optional[list[bytes]]]:
+    """Serialize (binary) a pymodaq object, if it is not JSON compatible."""
+    if isinstance(pymodaq_object, get_args(JSON_TYPES)):
+        return pymodaq_object, None
+    elif isinstance(pymodaq_object, get_args(SERIALIZABLE)):
+        return None, [Serializer(pymodaq_object).to_bytes()]
+    else:
+        raise ValueError(
+            f"{pymodaq_object} of type '{type(pymodaq_object).__name__}' is neither "
+            "JSON serializable, nor via PyMoDAQ."
+        )
+
+
+def binary_serialization_to_kwargs(
+    pymodaq_object: Union[SERIALIZABLE, Any], data_key: str = "data"
+) -> dict[str, Any]:
+    """Create a dictionary of data parameters and of additional payload to send."""
+    d, b = binary_serialization(pymodaq_object=pymodaq_object)
+    return {data_key: d, "additional_payload": b}
+
+
 def run_coordinator():
     command = [sys.executable, '-m', 'pyleco.coordinators.coordinator']
     subprocess.Popen(command)

{pymodaq-4.4.4.dist-info → pymodaq-4.4.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymodaq
-Version: 4.4.4
+Version: 4.4.6
 Summary: Modular Data Acquisition with Python
 Project-URL: Homepage, http://pymodaq.cnrs.fr
 Project-URL: Source, https://github.com/PyMoDAQ/PyMoDAQ
@@ -51,7 +51,7 @@ Requires-Dist: multipledispatch
 Requires-Dist: numpy<2.0.0
 Requires-Dist: packaging
 Requires-Dist: pint
-Requires-Dist: pyleco; python_version >= '3.8'
+Requires-Dist: pyleco>0.3; python_version >= '3.8'
 Requires-Dist: pymodaq-plugin-manager>=0.0.17
 Requires-Dist: pymodaq-plugins-mock<5.0.0
 Requires-Dist: pyqtgraph>=0.12

{pymodaq-4.4.4.dist-info → pymodaq-4.4.6.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=dUtqqmusaTSmnCcR-6tGHRwXM7zwV30viJFyQymZpAc,37346
+pymodaq/control_modules/daq_move.py,sha256=0zit9shAo6HAVxkaYdhhuSN-yu8j8T_TLSF6YOaM85Y,37842
 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=rtCTwYxb1gc7RSCNqT-MKm3LnAwOkN0Z3H7jTS1LRo8,42921
+pymodaq/control_modules/move_utility_classes.py,sha256=PDiPVAfOEAhtTc6MS0oVCy3AL-6KLSxOgYg3c5jctoA,43417
 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
@@ -18,6 +18,7 @@ pymodaq/examples/function_plotter.py,sha256=T-VT0Rd3jHP9GcR2h6Nao6lwZE06P8zWUbOl
 pymodaq/examples/nonlinearscanner.py,sha256=x0R2_FP0YnuOCCAmYRiAiZ1jfUdRxu5RqIYLyGQMZ0U,3790
 pymodaq/examples/parameter_ex.py,sha256=NmFUvUByNtm3j4leN_MkufQsKlNU8Rx5lmpsVG58IIM,8556
 pymodaq/examples/preset_MockCamera.xml,sha256=quQlMsX6YSoqqc9_9Y-9zu3TDM6Xvnuc2JSWwg9f948,15774
+pymodaq/examples/qt_less_standalone_module.py,sha256=9UD4niVfNXscDVQiOJuuL6lN9PC7Jfp9FwVJ0qz_6Do,4857
 pymodaq/examples/tcp_client.py,sha256=FSdPlb3R_rxxNIqPqHVU8PxJzNZeFk_93l4TqsB5SnA,2584
 pymodaq/examples/Labview_TCP_Client/DAQ_TCP_Client.aliases,sha256=t0eKH9Uq_AMk4wQ-6Pm5mKUjGcCvfT9GtvMsvDhkCUk,47
 pymodaq/examples/Labview_TCP_Client/DAQ_TCP_Client.lvlps,sha256=VZHH96rKSnRYKeCAXUmKI3vQOX8Wz53FYCF2yXuqnaU,84
@@ -58,11 +59,11 @@ 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=IfNU24BrE_7EQzoH3oufI-vneO5-lJnN8XQVcT-pk8w,19
+pymodaq/resources/VERSION,sha256=WLq0vLL18vLMV1jwQsziDmyw7JVoEVuWAB0pDGzYEvM,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
-pymodaq/resources/setup_plugin.py,sha256=yab26FHPB-zsUZ6ZiKQ7Rm9H1ZhoZW8RQoW4wPK-T94,3130
+pymodaq/resources/setup_plugin.py,sha256=jvMuSp4UxGaPUe9uPUvHg9DrdwyFakG6_sFy_zXb1f8,3182
 pymodaq/resources/triangulation_data.npy,sha256=Dzq6eE8f_i7Woloy1iUn6N1OfVdBZ4WnK4J4SCoqXso,9320
 pymodaq/resources/QtDesigner_Ressources/QtDesigner_ressources.bat,sha256=gqBmrc6Cfzn7wIZQtzgcglKRQ8zLXLW9Xt8LWxkJdw0,205
 pymodaq/resources/QtDesigner_Ressources/QtDesigner_ressources.qrc,sha256=S99847o7hvKYOWa9lR3qErMHwcjhjYPEduoq2ylCn4I,10123
@@ -311,7 +312,7 @@ pymodaq/utils/chrono_timer.py,sha256=rwX8apS8B-IKhA0Cp2H9tLz0BRN7G3Pg5ptozvd3MKM
 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=V4F_H-sUPmCwrcNDuF7JxzcJtnOlQX7fChSoyXdd6ng,111572
+pymodaq/utils/data.py,sha256=rasOk1-2o8fJHE_zm7ygrWXL7cBOHJOgwWMZhbVG7z0,111863
 pymodaq/utils/enums.py,sha256=wpRipioUJkKcEfoaY2NrDQ2WhGxZTZiZoJty5f2Ljpc,2236
 pymodaq/utils/exceptions.py,sha256=wLO6VlofzfwWkOOWMN2B-3NEWMfpgygyeEdakIx_rAs,668
 pymodaq/utils/factory.py,sha256=QLqAPFnTZ93eUpmAAIr7kESDk2enD57RNSuFUsjxE4E,2311
@@ -358,13 +359,13 @@ pymodaq/utils/h5modules/exporters/base.py,sha256=hGX2teIMO03QB0qBGTP4rzeXbZrQcVL
 pymodaq/utils/h5modules/exporters/flimj.py,sha256=z44C30KlAbaPmjnS5inYophnA18LwwqZOa1UMLEi4Tw,2361
 pymodaq/utils/h5modules/exporters/hyperspy.py,sha256=rheeVJQO0BAF606D_0S_j8huzOLzZfkUAp0OdJEnUz4,6517
 pymodaq/utils/leco/__init__.py,sha256=wxgCC-0eragO_REWDMp-2zg9kK5l_W9oO68dtRYdoKA,878
-pymodaq/utils/leco/daq_move_LECODirector.py,sha256=roAGsTCK4fZ--G3T2enRwD6i6wOuq1b7iwViuUi0noY,6382
-pymodaq/utils/leco/daq_xDviewer_LECODirector.py,sha256=DsB-rLdmmA7B_Iv3cN7wetjL_ZH6FA5ZXgB_Y3y_CY0,5990
+pymodaq/utils/leco/daq_move_LECODirector.py,sha256=neYq17utjIm_5KzJkglABd_iL0Ltolcri9oMcBDs-I8,6915
+pymodaq/utils/leco/daq_xDviewer_LECODirector.py,sha256=q6r-oJFMWqc0AOlRQShxX1w64LgnVVSyFzh3sSYUFV4,6310
 pymodaq/utils/leco/desktop.ini,sha256=2zopClaSQqdFfIsC8CGo2Oc-14x9h1gV0-fUrDtLFmA,82
 pymodaq/utils/leco/director_utils.py,sha256=f_rzS6p7VxfWvgm36JRgBHphqYMZrw3gqsadgF9ZtIg,2109
 pymodaq/utils/leco/leco_director.py,sha256=WPsZB6oJIkDJIqtagbeuErfpGB-ENF-s0rtoj_EGVdM,3054
-pymodaq/utils/leco/pymodaq_listener.py,sha256=Nfk4iLrKaCsiEIR75h84XXMWJwp4E8g8CWgdbFV4YqQ,10699
-pymodaq/utils/leco/utils.py,sha256=yzLqAaZhfALmsrU4wlNGSnRYBiivYCFm9MZvzmZodog,1394
+pymodaq/utils/leco/pymodaq_listener.py,sha256=OmYC6c3OYjqcT7M881b-g8lXIua2Pq-YYv4X_TuxaPM,10802
+pymodaq/utils/leco/utils.py,sha256=jCHhco89uG9UA-t9LpaEuyZQMQW5XQP_t0URcvqLDNU,2362
 pymodaq/utils/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pymodaq/utils/managers/action_manager.py,sha256=v99NuRq7uT_PNTAsqbUyoWyDGUzhlP6dYtdAO30_cbc,17756
 pymodaq/utils/managers/batchscan_manager.py,sha256=jcL08YvFafX5kiy03BV1_6obt2Xogiby5pvTKeN8_ho,13905
@@ -438,8 +439,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=htVQCE4saRBMeIcseEyxTt5G58A341m6OGkaJUA34Wk,27766
 pymodaq/utils/tcp_ip/tcp_server_client.py,sha256=xIMTNgVW_rKK0yTi4FDNFLf85-Akb27Jz2LdrvOrP68,30660
-pymodaq-4.4.4.dist-info/METADATA,sha256=99QWFIuxJRvs7aDQhZQgfk2iv3rVqyKSCi0nGgQ9xJU,7623
-pymodaq-4.4.4.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-pymodaq-4.4.4.dist-info/entry_points.txt,sha256=RAzdYNjvUT28I2eiCKki_g2NzXq0woWxhev6lwzwRv8,348
-pymodaq-4.4.4.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
-pymodaq-4.4.4.dist-info/RECORD,,
+pymodaq-4.4.6.dist-info/METADATA,sha256=mJV-zKqrF_yCIPzo_-brHM2vJqBIdptzQPzVJ8qmIbM,7627
+pymodaq-4.4.6.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+pymodaq-4.4.6.dist-info/entry_points.txt,sha256=RAzdYNjvUT28I2eiCKki_g2NzXq0woWxhev6lwzwRv8,348
+pymodaq-4.4.6.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
+pymodaq-4.4.6.dist-info/RECORD,,