pymodaq 4.4.5__py3-none-any.whl → 4.4.7__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.5'
+version = '4.4.7'
 

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

@@ -98,6 +98,7 @@ class DataUnitError(Exception):
 
 
 class DwaType(BaseEnum):
+    """Different types of `DataWithAxes`."""
     DataWithAxes = 0
     DataRaw = 1
     DataActuator = 2
@@ -648,6 +649,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/utils/managers/remote_manager.py

@@ -17,7 +17,7 @@ logger = set_logger(get_module_name(__file__))
 remote_path = pymodaq.utils.config.get_set_remote_path()
 remote_types = ['ShortCut', 'Joystick']
 
-actuator_actions = ['move_Rel', 'move_Rel_p', 'move_Rel_m']
+actuator_actions = ['move_rel', 'move_rel_p', 'move_rel_m']
 detector_actions = ['snap', 'grab', 'stop']
 remote_types = ['Keyboard', 'Joystick']
 try:

pymodaq/utils/tcp_ip/serializer.py

@@ -5,8 +5,9 @@ Created the 20/10/2023
 @author: Sebastien Weber
 """
 from base64 import b64encode, b64decode
+from enum import Enum
 import numbers
-from typing import Tuple, List, Union, TYPE_CHECKING, Iterable
+from typing import Optional, Tuple, List, Union, TYPE_CHECKING
 
 
 import numpy as np
@@ -20,17 +21,38 @@ if TYPE_CHECKING:
 
 
 SERIALIZABLE = Union[
-    int,
+    # native
+    bool,
+    bytes,
     str,
-    numbers.Number,
+    complex,  # float and int are subtypes for type hinting
+    float,
+    int,
     list,
+    # numpy
     np.ndarray,
+    # pymodaq
     Axis,
     DataWithAxes,
     DataToExport,
+    putils.ParameterWithPath,
 ]
 
 
+class SerializableTypes(Enum):
+    """Type names of serializable types"""
+    BOOL = "bool"
+    BYTES = "bytes"
+    STRING = "string"
+    SCALAR = "scalar"
+    LIST = "list"
+    ARRAY = "array"
+    AXIS = "axis"
+    DATA_WITH_AXES = "dwa"
+    DATA_TO_EXPORT = "dte"
+    PARAMETER = "parameter"
+
+
 class SocketString:
     """Mimic the Socket object but actually using a bytes string not a socket connection
 
@@ -86,7 +108,7 @@ class Serializer:
     """Used to Serialize to bytes python objects, numpy arrays and PyMoDAQ DataWithAxes and
     DataToExport objects"""
 
-    def __init__(self, obj: SERIALIZABLE = None):
+    def __init__(self, obj: Optional[SERIALIZABLE] = None) -> None:
         self._bytes_string = b''
         self._obj = obj
 
@@ -154,7 +176,7 @@ class Serializer:
         return message.encode()
 
     @classmethod
-    def str_len_to_bytes(cls, message: Union[str, bytes]) -> (bytes, bytes):
+    def str_len_to_bytes(cls, message: Union[str, bytes]) -> Tuple[bytes, bytes]:
         """ Convert a string and its length to two bytes
         Parameters
         ----------
@@ -174,7 +196,7 @@ class Serializer:
         return message, cls.int_to_bytes(len(message))
 
     def _int_serialization(self, int_obj: int) -> bytes:
-        """serialize an unsigned integer used for getting the length of messages internaly, for outside integer
+        """Serialize an unsigned integer used for getting the length of messages internally, for outside integer
         serialization or deserialization use scalar_serialization"""
         int_bytes = self.int_to_bytes(int_obj)
         bytes_string = int_bytes
@@ -205,18 +227,19 @@ class Serializer:
         self._bytes_string += bytes_string
         return bytes_string
 
-    def scalar_serialization(self, scalar: numbers.Number) -> bytes:
+    def scalar_serialization(self, scalar: complex) -> bytes:
         """ Convert a scalar into a bytes message together with the info to convert it back
 
         Parameters
         ----------
-        scalar: str
+        scalar: A python number (complex or subtypes like float and int)
 
         Returns
         -------
         bytes: the total bytes message to serialize the scalar
         """
         if not isinstance(scalar, numbers.Number):
+            # type hint is complex, instance comparison Number
             raise TypeError(f'{scalar} should be an integer or a float, not a {type(scalar)}')
         scalar_array = np.array([scalar])
         data_type = scalar_array.dtype.descr[0][1]
@@ -350,49 +373,56 @@ class Serializer:
         self._bytes_string += bytes_string
         return bytes_string
 
-    def type_and_object_serialization(self, obj):
+    def type_and_object_serialization(self, obj: Optional[SERIALIZABLE] = None) -> bytes:
+        """Serialize an object with its type, such that it can be retrieved by
+        `DeSerializer.type_and_object_deserialization`.
+        """
+
+        if obj is None and self._obj is not None:
+            obj = self._obj
+
         bytes_string = b''
         if isinstance(obj, DataWithAxes):
-            bytes_string += self.string_serialization('dwa')
+            bytes_string += self.string_serialization(SerializableTypes.DATA_WITH_AXES.value)
             bytes_string += self.dwa_serialization(obj)
 
         elif isinstance(obj, Axis):
-            bytes_string += self.string_serialization('axis')
+            bytes_string += self.string_serialization(SerializableTypes.AXIS.value)
             bytes_string += self.axis_serialization(obj)
 
         elif isinstance(obj, np.ndarray):
-            bytes_string += self.string_serialization('array')
+            bytes_string += self.string_serialization(SerializableTypes.ARRAY.value)
             bytes_string += self.ndarray_serialization(obj)
 
         elif isinstance(obj, bytes):
-            bytes_string += self.string_serialization('bytes')
+            bytes_string += self.string_serialization(SerializableTypes.BYTES.value)
             bytes_string += self.bytes_serialization(obj)
 
         elif isinstance(obj, str):
-            bytes_string += self.string_serialization('string')
+            bytes_string += self.string_serialization(SerializableTypes.STRING.value)
             bytes_string += self.string_serialization(obj)
 
-        elif isinstance(obj, numbers.Number):
-            bytes_string += self.string_serialization('scalar')
+        elif isinstance(obj, bool):
+            bytes_string += self.string_serialization(SerializableTypes.BOOL.value)
             bytes_string += self.scalar_serialization(obj)
 
-        elif isinstance(obj, bool):
-            bytes_string += self.string_serialization('bool')
-            bytes_string += self.scalar_serialization(int(obj))
+        elif isinstance(obj, numbers.Number):
+            bytes_string += self.string_serialization(SerializableTypes.SCALAR.value)
+            bytes_string += self.scalar_serialization(obj)
 
         elif isinstance(obj, list):
-            bytes_string += self.string_serialization('list')
+            bytes_string += self.string_serialization(SerializableTypes.LIST.value)
             bytes_string += self.list_serialization(obj)
 
         elif isinstance(obj, putils.ParameterWithPath):
             path = obj.path
             param_as_xml = ioxml.parameter_to_xml_string(obj.parameter)
-            bytes_string += self.string_serialization('parameter')
+            bytes_string += self.string_serialization(SerializableTypes.PARAMETER.value)
             bytes_string += self.list_serialization(path)
-            bytes_string += self.string_serialization(param_as_xml)
+            bytes_string += self.bytes_serialization(param_as_xml)
 
         elif isinstance(obj, DataToExport):
-            bytes_string += self.string_serialization('dte')
+            bytes_string += self.string_serialization(SerializableTypes.DATA_TO_EXPORT.value)
             bytes_string += self.dte_serialization(obj)
 
         else:
@@ -509,7 +539,7 @@ class DeSerializer:
     :py:class:`~pymodaq.utils.tcp_ip.mysocket.Socket`
     """
 
-    def __init__(self, bytes_string:  Union[bytes, 'Socket'] = None):
+    def __init__(self, bytes_string:  Union[bytes, 'Socket'] = None) -> None:
         if isinstance(bytes_string, bytes):
             bytes_string = SocketString(bytes_string)
         self._bytes_string = bytes_string
@@ -531,7 +561,7 @@ class DeSerializer:
         return int.from_bytes(bytes_string, 'big')
 
     @staticmethod
-    def bytes_to_scalar(data: bytes, dtype: np.dtype) -> numbers.Number:
+    def bytes_to_scalar(data: bytes, dtype: np.dtype) -> complex:
         """Convert bytes to a scalar given a certain numpy dtype
 
         Parameters
@@ -588,8 +618,8 @@ class DeSerializer:
         str_obj = self._bytes_string.get_first_nbytes(string_len).decode()
         return str_obj
 
-    def scalar_deserialization(self) -> numbers.Number:
-        """Convert bytes into a numbers.Number object
+    def scalar_deserialization(self) -> complex:
+        """Convert bytes into a python number object
 
         Get first the data type from a string deserialization, then the data length and finally convert this
         length of bytes into a number (float, int)
@@ -602,9 +632,11 @@ class DeSerializer:
         data_len = self._int_deserialization()
         number = np.frombuffer(self._bytes_string.get_first_nbytes(data_len), dtype=data_type)[0]
         if 'f' in data_type:
-            number = float(number)  # because one get numpy  float type
+            number = float(number)  # because one get numpy float type
         elif 'i' in data_type:
             number = int(number)  # because one get numpy int type
+        elif 'c' in data_type:
+            number = complex(number)  # because one get numpy complex type
         return number
 
     def boolean_deserialization(self) -> bool:
@@ -642,7 +674,7 @@ class DeSerializer:
         ndarray = np.atleast_1d(ndarray)  # remove singleton dimensions
         return ndarray
 
-    def type_and_object_deserialization(self):
+    def type_and_object_deserialization(self) -> SERIALIZABLE:
         """ Deserialize specific objects from their binary representation (inverse of `Serializer.type_and_object_serialization`).
 
         See Also
@@ -652,28 +684,29 @@ class DeSerializer:
         """
         obj_type = self.string_deserialization()
         elt = None
-        if obj_type == 'scalar':
+        if obj_type == SerializableTypes.SCALAR.value:
             elt = self.scalar_deserialization()
-        elif obj_type == 'string':
+        elif obj_type == SerializableTypes.STRING.value:
             elt = self.string_deserialization()
-        elif obj_type == 'bytes':
+        elif obj_type == SerializableTypes.BYTES.value:
             elt = self.bytes_deserialization()
-        elif obj_type == 'array':
+        elif obj_type == SerializableTypes.ARRAY.value:
             elt = self.ndarray_deserialization()
-        elif obj_type == 'dwa':
+        elif obj_type == SerializableTypes.DATA_WITH_AXES.value:
             elt = self.dwa_deserialization()
-        elif obj_type == 'dte':
+        elif obj_type == SerializableTypes.DATA_TO_EXPORT.value:
             elt = self.dte_deserialization()
-        elif obj_type == 'axis':
+        elif obj_type == SerializableTypes.AXIS.value:
             elt = self.axis_deserialization()
-        elif obj_type == 'bool':
+        elif obj_type == SerializableTypes.BOOL.value:
             elt = self.boolean_deserialization()
-        elif obj_type == 'list':
+        elif obj_type == SerializableTypes.LIST.value:
             elt = self.list_deserialization()
-        elif obj_type == 'parameter':
+        elif obj_type == SerializableTypes.PARAMETER.value:
             elt = self.parameter_deserialization()
         else:
             print(f'invalid object type {obj_type}')
+            elt = None  # desired behavior?
         return elt
 
     def list_deserialization(self) -> list:
@@ -774,4 +807,4 @@ class DeSerializer:
                            data=self.list_deserialization(),
                            )
         dte.timestamp = timestamp
-        return dte
+        return dte

{pymodaq-4.4.5.dist-info → pymodaq-4.4.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pymodaq
-Version: 4.4.5
+Version: 4.4.7
 Summary: Modular Data Acquisition with Python
 Project-URL: Homepage, http://pymodaq.cnrs.fr
 Project-URL: Source, https://github.com/PyMoDAQ/PyMoDAQ
@@ -27,7 +27,6 @@ License: The MIT License (MIT)
         LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
         OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
         THE SOFTWARE.
-License-File: LICENSE
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Other Environment
 Classifier: Intended Audience :: Science/Research
@@ -51,7 +50,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.5.dist-info → pymodaq-4.4.7.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=6GGzX89SPwPeU5-Ey0MEM9ZwzJfhrT2qOR8OxMQdnVA,19
+pymodaq/resources/VERSION,sha256=ib4rQ9G3YTfdijgNEWBcOoAIZQyUy-mfF0jvGog9fno,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=RdzEDz3ziRmwbaqy875fLr06jrmaG1wzU-0e_5QQKXM,111908
 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
@@ -373,7 +374,7 @@ pymodaq/utils/managers/overshoot_manager.py,sha256=fe_CR1Bkw85BER34MoVFlm-xtKl9H
 pymodaq/utils/managers/parameter_manager.py,sha256=hO3RXcpkYOtuqjAQaD5H3r71rVEHntYg64VHZwVCQBg,11473
 pymodaq/utils/managers/preset_manager.py,sha256=m8r_TcfFbUatddBX9SJj7XI_GZ3FhoiwzhFgocw9jZ8,9481
 pymodaq/utils/managers/preset_manager_utils.py,sha256=d148YBjeNOP9FTkFoTsfdRDxMIXOR8JJHqbOmoL2aVA,8155
-pymodaq/utils/managers/remote_manager.py,sha256=H6k9aiBkuJRJbZ4rpd5jfawQ-pMRFAXOE_miakvciP8,22251
+pymodaq/utils/managers/remote_manager.py,sha256=SwzefJuGpgzvvjTbJSo3T3Rc2rncvHHyPYPBd8gCQX8,22251
 pymodaq/utils/managers/roi_manager.py,sha256=RRICNSLMxiUoq8tEBKihpdydIVAu78ogkYOFWWphaHE,29892
 pymodaq/utils/parameter/__init__.py,sha256=fMljZeQ9EVvh2bmss550C5BpxFeKOxT8_AVJdPxQ0kQ,433
 pymodaq/utils/parameter/ioxml.py,sha256=jduHhMrpc0lkSJlznnI-LRHUJ0Ofc4PoFfNlxLbLmw8,17091
@@ -436,10 +437,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=htVQCE4saRBMeIcseEyxTt5G58A341m6OGkaJUA34Wk,27766
+pymodaq/utils/tcp_ip/serializer.py,sha256=kXmvFLR5ZedjY2rVGUs83lsJk9Z9l_iAWR6srDxzaYQ,29262
 pymodaq/utils/tcp_ip/tcp_server_client.py,sha256=xIMTNgVW_rKK0yTi4FDNFLf85-Akb27Jz2LdrvOrP68,30660
-pymodaq-4.4.5.dist-info/METADATA,sha256=fXPlSRBE34NGAV3RqrDaPq36CdNaU35PW6Yke889ZCI,7629
-pymodaq-4.4.5.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-pymodaq-4.4.5.dist-info/entry_points.txt,sha256=RAzdYNjvUT28I2eiCKki_g2NzXq0woWxhev6lwzwRv8,348
-pymodaq-4.4.5.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
-pymodaq-4.4.5.dist-info/RECORD,,
+pymodaq-4.4.7.dist-info/METADATA,sha256=jkmtri16XiPHC-2It45CeeZp--C6giXVJ0FLp3g13u8,7611
+pymodaq-4.4.7.dist-info/WHEEL,sha256=3U_NnUcV_1B1kPkYaPzN-irRckL5VW_lytn0ytO_kRY,87
+pymodaq-4.4.7.dist-info/entry_points.txt,sha256=RAzdYNjvUT28I2eiCKki_g2NzXq0woWxhev6lwzwRv8,348
+pymodaq-4.4.7.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
+pymodaq-4.4.7.dist-info/RECORD,,

{pymodaq-4.4.5.dist-info → pymodaq-4.4.7.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.25.0
+Generator: hatchling 1.26.1
 Root-Is-Purelib: true
 Tag: py3-none-any