pymodaq 4.4.5__tar.gz → 4.4.7__tar.gz

{pymodaq-4.4.5 → pymodaq-4.4.7}/.gitignore

@@ -127,3 +127,4 @@ venv.bak/
 *yacctab.py
 *lextab.py
 
+.mu_repo

{pymodaq-4.4.5 → pymodaq-4.4.7}/PKG-INFO

@@ -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 → pymodaq-4.4.7}/pyproject.toml

@@ -51,8 +51,8 @@ dependencies = [
     "toml",
     "qtconsole",
     "tables<3.9",  # issue with some version of required package blosc2>=2.2.8
-    "pyleco; python_version>=\"3.8\"",
-    "bayesian-optimization<2.0.0"
+    "pyleco>0.3; python_version>=\"3.8\"",
+    "bayesian-optimization<2.0.0",
 ]
 
 [project.scripts]

{pymodaq-4.4.5 → pymodaq-4.4.7}/src/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-4.4.5 → pymodaq-4.4.7}/src/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-4.4.7/src/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-4.4.7/src/pymodaq/resources/VERSION

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

{pymodaq-4.4.5 → pymodaq-4.4.7}/src/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-4.4.5 → pymodaq-4.4.7}/src/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-4.4.5 → pymodaq-4.4.7}/src/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-4.4.5 → pymodaq-4.4.7}/src/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-4.4.5 → pymodaq-4.4.7}/src/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-4.4.5 → pymodaq-4.4.7}/src/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.5 → pymodaq-4.4.7}/src/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: