pymodaq 5.0.18__py3-none-any.whl → 5.1.0__py3-none-any.whl

pymodaq/utils/leco/pymodaq_listener.py

@@ -3,19 +3,31 @@ from pymodaq_utils.enums import StrEnum
 
 import logging
 from threading import Event
-from typing import Optional, Union, List, Type
+from typing import cast, Optional, Union, List, Sequence, Type
 
 from pyleco.core import COORDINATOR_PORT
+from pyleco.json_utils.errors import JSONRPCError, RECEIVER_UNKNOWN, NODE_UNKNOWN
 from pyleco.utils.listener import Listener, PipeHandler
 from qtpy.QtCore import QObject, Signal  # type: ignore
 
+from pymodaq_data.data import DataWithAxes
+from pymodaq_utils.serialize.factory import SerializableFactory, SerializableBase
 from pymodaq_utils.utils import ThreadCommand
 from pymodaq_gui.parameter import ioxml
-from pymodaq_data.data import DataWithAxes
-from pymodaq_utils.serialize.serializer_legacy import SERIALIZABLE, DeSerializer
+from pymodaq_gui.parameter.utils import ParameterWithPath
+
 from pymodaq.utils.leco.utils import binary_serialization_to_kwargs
+from pymodaq.utils.leco.rpc_method_definitions import (
+    GenericMethods,
+    MoveMethods,
+    ViewerMethods,
+    GenericDirectorMethods,
+    MoveDirectorMethods,
+    ViewerDirectorMethods,
+)
 
 
+# Commands for ThreadCommand
 class LECOClientCommands(StrEnum):
     LECO_CONNECTED = "leco_connected"
     LECO_DISCONNECTED = "leco_disconnected"
@@ -24,15 +36,28 @@ class LECOClientCommands(StrEnum):
 class LECOCommands(StrEnum):
     CONNECT = "ini_connection"
     QUIT = "quit"
+    GET_SETTINGS = 'get_settings'
+    SET_DIRECTOR_SETTINGS = 'set_director_settings'
+    SET_INFO = 'set_info'
+    SEND_INFO = 'send_info'
 
 
 class LECOMoveCommands(StrEnum):
     POSITION = 'position_is'
     MOVE_DONE = 'move_done'
+    UNITS_CHANGED = 'units_changed'
+    STOP = 'stop_motion'
+    MOVE_ABS = 'move_abs'
+    MOVE_REL = 'move_rel'
+    MOVE_HOME = 'move_home'
+    GET_ACTUATOR_VALUE = 'get_actuator_value'
 
 
 class LECOViewerCommands(StrEnum):
     DATA_READY = 'data_ready'
+    GRAB = 'grab'
+    SNAP = 'snap'
+    STOP = 'stop_grab'
 
 
 class ListenerSignals(QObject):
@@ -53,54 +78,120 @@ class PymodaqPipeHandler(PipeHandler):
     def __init__(self, name: str, signals: ListenerSignals, **kwargs) -> None:
         super().__init__(name, **kwargs)
         self.signals = signals
-
+        self.register_data_types_for_deserialization()
+
+    def register_data_types_for_deserialization(
+        self, types: Optional[Sequence[type[SerializableBase]]] = None
+    ) -> None:
+        """Register different data types for deserialization in subclasses."""
+        if types is None:
+            return
+        for cls in types:
+            SerializableFactory().register_from_type(
+                cls, cls.serialize, cls.deserialize
+            )
 
 class ActorHandler(PymodaqPipeHandler):
+    def register_data_types_for_deserialization(
+        self, types: Optional[Sequence[type[SerializableBase]]] = None
+    ) -> None:
+        all_types: Sequence[type[SerializableBase]] = [DataWithAxes]
+        if types:
+            all_types.extend(types)  # type: ignore
+        super().register_data_types_for_deserialization(all_types)
 
     def register_rpc_methods(self) -> None:
         super().register_rpc_methods()
-        self.register_rpc_method(self.set_info)
-        self.register_rpc_method(self.send_data)
-        self.register_rpc_method(self.move_abs)
-        self.register_rpc_method(self.move_rel)
-        self.register_rpc_method(self.move_home)
-        self.register_rpc_method(self.get_actuator_value)
-        self.register_rpc_method(self.stop_motion)
+        self.register_binary_rpc_method(
+            self.set_info, name=GenericMethods.SET_INFO, accept_binary_input=True
+        )
+        self.register_rpc_method(self.send_data_grab, name=ViewerMethods.GRAB)
+        self.register_rpc_method(self.send_data_snap, name=ViewerMethods.SNAP)
+        self.register_binary_rpc_method(
+            self.move_abs, accept_binary_input=True, name=MoveMethods.MOVE_ABS
+        )
+        self.register_binary_rpc_method(
+            self.move_rel, accept_binary_input=True, name=MoveMethods.MOVE_REL
+        )
+        self.register_rpc_method(self.move_home, name=MoveMethods.MOVE_HOME)
+        self.register_rpc_method(self.get_actuator_value, name=MoveMethods.GET_ACTUATOR_VALUE)
+        self.register_rpc_method(self.stop_motion, name=MoveMethods.STOP_MOTION)
+        self.register_rpc_method(self.stop_grab, name=ViewerMethods.STOP)
+        self.register_rpc_method(self.get_settings, name=GenericMethods.GET_SETTINGS)
 
     @staticmethod
-    def extract_dwa_object(data_string: str) -> DataWithAxes:
-        """Extract a DataWithAxes object from the received message."""
-        desererializer = DeSerializer.from_b64_string(data_string)
-        return desererializer.dwa_deserialization()
+    def extract_pymodaq_object(
+        value: Optional[Union[float, str]], additional_payload: Optional[List[bytes]]
+    ):
+        if value is None and additional_payload:
+            return cast(
+                DataWithAxes, SerializableFactory().get_apply_deserializer(additional_payload[0])
+            )
+        else:
+            return value
 
     # generic commands
-    def set_info(self, path: List[str], param_dict_str: str) -> None:
-        self.signals.cmd_signal.emit(ThreadCommand("set_info", attribute=[path, param_dict_str]))
+    def set_info(self,
+                 parameter: Optional[Union[float, str]],
+                 additional_payload: Optional[List[bytes]] = None,
+                 ) -> None:
+        assert additional_payload
+        param = cast(
+            ParameterWithPath, SerializableFactory().get_apply_deserializer(additional_payload[0])
+        )
+        self.signals.cmd_signal.emit(ThreadCommand(LECOCommands.SET_INFO, attribute=param))
+
+    def get_settings(self):
+        self.signals.cmd_signal.emit(ThreadCommand(LECOCommands.GET_SETTINGS))
 
     # detector commands
-    def send_data(self, grabber_type: str = "") -> None:
-        self.signals.cmd_signal.emit(ThreadCommand(f"Send Data {grabber_type}"))
+    def send_data_grab(self,) -> None:
+        self.signals.cmd_signal.emit(ThreadCommand(LECOViewerCommands.GRAB))
 
-    # actuator commands
-    def move_abs(self, position: Union[float, str]) -> None:
-        pos = self.extract_dwa_object(position) if isinstance(position, str) else position
-        self.signals.cmd_signal.emit(ThreadCommand("move_abs", attribute=[pos]))
+    # detector commands
+    def send_data_snap(self,) -> None:
+        self.signals.cmd_signal.emit(ThreadCommand(LECOViewerCommands.SNAP))
 
-    def move_rel(self, position: Union[float, str]) -> None:
-        pos = self.extract_dwa_object(position) if isinstance(position, str) else position
-        self.signals.cmd_signal.emit(ThreadCommand("move_rel", attribute=[pos]))
+    # actuator commands
+    def move_abs(
+        self,
+        position: Optional[Union[float, str]],
+        additional_payload: Optional[List[bytes]] = None,
+    ) -> None:
+        """Move to an absolute position.
+
+        :param position: Deprecated, should be None and content transferred binary.
+        :param additional_payload: binary frames containing the position as PyMoDAQ `DataActuator`.
+        """
+        pos = self.extract_pymodaq_object(position, additional_payload)
+        self.signals.cmd_signal.emit(ThreadCommand(LECOMoveCommands.MOVE_ABS, pos))
+
+    def move_rel(
+        self,
+        position: Optional[Union[float, str]],
+        additional_payload: Optional[List[bytes]] = None,
+    ) -> None:
+        """Move by a relative position.
+
+        :param position: Deprecated, should be None and content transferred binary.
+        :param additional_payload: binary frames containing the position as PyMoDAQ `DataActuator`.
+        """
+        pos = self.extract_pymodaq_object(position, additional_payload)
+        self.signals.cmd_signal.emit(ThreadCommand(LECOMoveCommands.MOVE_REL, pos))
 
     def move_home(self) -> None:
-        self.signals.cmd_signal.emit(ThreadCommand("move_home"))
+        self.signals.cmd_signal.emit(ThreadCommand(LECOMoveCommands.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"
-        self.signals.cmd_signal.emit(ThreadCommand("get_actuator_value"))
+        self.signals.cmd_signal.emit(ThreadCommand(LECOMoveCommands.GET_ACTUATOR_VALUE))
 
     def stop_motion(self,) -> None:
-        # not implemented in DAQ_Move!
-        self.signals.cmd_signal.emit(ThreadCommand("stop_motion"))
+        self.signals.cmd_signal.emit(ThreadCommand(LECOMoveCommands.STOP))
+
+    def stop_grab(self,) -> None:
+        self.signals.cmd_signal.emit(ThreadCommand(LECOViewerCommands.STOP))
 
 
 # to be able to separate them later on
@@ -115,7 +206,7 @@ class PymodaqListener(Listener):
     :param host: Host name of the communication server.
     :param port: Port number of the communication server.
     """
-    remote_name: str = ""
+    remote_names: set[str]
 
     local_methods = ["pong", "set_log_level"]
 
@@ -129,6 +220,7 @@ class PymodaqListener(Listener):
                  **kwargs) -> None:
         super().__init__(name, host, port, logger=logger, timeout=timeout,
                          **kwargs)
+        self.remote_names = set()
         self.signals = ListenerSignals()
         # self.signals.message.connect(self.handle_message)
         self.cmd_signal = self.signals.cmd_signal
@@ -176,13 +268,17 @@ class ActorListener(PymodaqListener):
 
     def start_listen(self) -> None:
         super().start_listen()
-        self.message_handler.register_rpc_method(self.set_remote_name)
+        self.message_handler.register_rpc_method(
+            self.set_remote_name, name=GenericMethods.SET_REMOTE_NAME
+        )
 
     def set_remote_name(self, name: str) -> None:
         """Define what the name of the remote for answers is."""
-        self.remote_name = name
+        self.remote_names.add(name)
+
+    def remove_remote_name(self, name: str) -> None:
+        self.remote_names.discard(name)
 
-    # @Slot(ThreadCommand)
     def queue_command(self, command: ThreadCommand) -> None:
         """Queue a command to send it via LECO to the server."""
 
@@ -203,71 +299,64 @@ class ActorListener(PymodaqListener):
             finally:
                 self.cmd_signal.emit(ThreadCommand('disconnected'))
 
-        elif command.command == 'update_connection':
-            # self.ipaddress = command.attribute['ipaddress']
-            # self.port = command.attribute['port']
-            pass  # TODO change name?
-
-        elif command.command == LECOViewerCommands.DATA_READY:
-            # code from the original:
-            # self.data_ready(data=command.attribute)
-            # def data_ready(data): self.send_data(datas[0]['data'])
-            value = command.attribute  # type: ignore
-            self.communicator.ask_rpc(
-                receiver=self.remote_name,
-                method="set_data",
-                **binary_serialization_to_kwargs(value),
-            )
-
-        elif command.command == 'send_info':
-            path = command.attribute['path']  # type: ignore
-            param = command.attribute['param']  # type: ignore
-            self.communicator.ask_rpc(
-                receiver=self.remote_name,
-                method="set_info",
-                path=path,
-                param_dict_str=ioxml.parameter_to_xml_string(param).decode())
-
-        elif command.command == LECOMoveCommands.POSITION:
-            value = command.attribute[0]  # type: ignore
-            self.communicator.ask_rpc(receiver=self.remote_name,
-                                      method="set_position",
-                                      **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",
-                                      **binary_serialization_to_kwargs(value, data_key="position"),
-                                      )
-
-        elif command.command == 'x_axis':
-            value = command.attribute[0]  # type: ignore
-            if isinstance(value, SERIALIZABLE):
-                self.communicator.ask_rpc(receiver=self.remote_name,
-                                          method="set_x_axis",
-                                          **binary_serialization_to_kwargs(value),
-                                          )
-            elif isinstance(value, dict):
-                self.communicator.ask_rpc(receiver=self.remote_name, method="set_x_axis", **value)
-            else:
-                raise ValueError("Nothing to send!")
-
-        elif command.command == 'y_axis':
-            value = command.attribute[0]  # type: ignore
-            if isinstance(value, SERIALIZABLE):
-                self.communicator.ask_rpc(receiver=self.remote_name,
-                                          method="set_y_axis",
-                                          **binary_serialization_to_kwargs(value),
-                                          )
-            elif isinstance(value, dict):
-                self.communicator.ask_rpc(receiver=self.remote_name, method="set_y_axis", **value)
-            else:
-                raise ValueError("Nothing to send!")
+        elif command.attribute is not None:
+            # here are all methods requiring an attribute in the ThreadCommand
+
+            if command.command == LECOViewerCommands.DATA_READY:
+                value = command.attribute
+                self.send_rpc_message_to_remote(
+                    method=ViewerDirectorMethods.SET_DATA,
+                    **binary_serialization_to_kwargs(value),
+                )
+
+            elif command.command == LECOCommands.SEND_INFO:
+                self.send_rpc_message_to_remote(
+                    method=GenericDirectorMethods.SET_DIRECTOR_INFO,
+                    **binary_serialization_to_kwargs(command.attribute, data_key='parameter'))
+
+            elif command.command == LECOMoveCommands.POSITION:
+                value = command.attribute
+                if isinstance(value, (list, tuple)):
+                    value = value[0]  # for backward compatibility with attributes list
+                self.send_rpc_message_to_remote(
+                    method=MoveDirectorMethods.SEND_POSITION,
+                    **binary_serialization_to_kwargs(pymodaq_object=value, data_key="position"),
+                )
+
+            elif command.command == LECOMoveCommands.MOVE_DONE:
+                value = command.attribute
+                if isinstance(value, (list, tuple)):
+                    value = value[0]  # for backward compatibility with attributes list
+                self.send_rpc_message_to_remote(
+                    method=MoveDirectorMethods.SET_MOVE_DONE,
+                    **binary_serialization_to_kwargs(value, data_key="position"),
+                )
+
+            elif command.command == LECOMoveCommands.UNITS_CHANGED:
+                units: str = command.attribute
+                self.send_rpc_message_to_remote(
+                    method=MoveDirectorMethods.SET_UNITS,
+                    units=units.encode(),
+                )
+
+            elif command.command == LECOCommands.SET_DIRECTOR_SETTINGS:
+                self.send_rpc_message_to_remote(
+                    method=GenericDirectorMethods.SET_DIRECTOR_SETTINGS,
+                    settings=command.attribute.decode(),
+                )
 
         else:
-            raise IOError('Unknown TCP client command')
+            raise IOError("Unknown TCP client command")
+
+    def send_rpc_message_to_remote(self, method: str, **kwargs) -> None:
+        if not self.remote_names:
+            return
+        for name in list(self.remote_names):
+            try:
+                self.communicator.ask_rpc(receiver=name, method=method, **kwargs)
+            except JSONRPCError as exc:
+                if exc.rpc_error.code in (RECEIVER_UNKNOWN.code, NODE_UNKNOWN.code):
+                    self.remove_remote_name(name)
 
 
 # to be able to separate them later on

pymodaq/utils/leco/rpc_method_definitions.py

@@ -0,0 +1,43 @@
+"""
+Names of methods used between remotely controlled modules and
+remote controlling director modules.
+"""
+
+from pymodaq_utils.enums import StrEnum
+
+
+# Methods for all PyMoDAQ modules
+class GenericMethods(StrEnum):
+    SET_INFO = "set_info"
+    GET_SETTINGS = "get_settings"
+    SET_REMOTE_NAME = "set_remote_name"
+
+
+class MoveMethods(StrEnum):
+    MOVE_ABS = "move_abs"
+    MOVE_REL = "move_rel"
+    MOVE_HOME = "move_home"
+    STOP_MOTION = "stop_motion"
+    GET_ACTUATOR_VALUE = "get_actuator_value"
+
+
+class ViewerMethods(StrEnum):
+    GRAB = "send_data_grab"
+    SNAP = "send_data_snap"
+    STOP = "stop_grab"
+
+
+# Director module methods
+class GenericDirectorMethods(StrEnum):
+    SET_DIRECTOR_SETTINGS = "set_director_settings"
+    SET_DIRECTOR_INFO = "set_director_info"
+
+
+class MoveDirectorMethods(StrEnum):
+    SET_UNITS = "set_units"
+    SEND_POSITION = "send_position"
+    SET_MOVE_DONE = "set_move_done"
+
+
+class ViewerDirectorMethods(StrEnum):
+    SET_DATA = "set_data"

pymodaq/utils/leco/utils.py

@@ -3,27 +3,17 @@ import subprocess
 import sys
 from typing import Any, Optional, Union, get_args, TypeVar
 
+
 from pymodaq.utils import data
-# import also the DeSerializer for easier imports in dependents
-from pymodaq_utils.serialize.serializer_legacy import Serializer, DeSerializer, SerializableFactory
+from pymodaq_utils.serialize.factory import SerializableFactory
 
-# type: ignore  # noqa
 from pymodaq_utils.logger import set_logger
 
 
 logger = set_logger('leco_utils')
-ser_factory = SerializableFactory()
-JSON_TYPES = Union[str, int, float]
-
+JSON_TYPES = Union[str, int, float, list]
 
-
-def serialize_object(pymodaq_object: Union[SERIALIZABLE, Any]) -> Union[str, Any]:
-    """Serialize a pymodaq object, if it is not JSON compatible."""
-    if isinstance(pymodaq_object, get_args(JSON_TYPES)):
-        return pymodaq_object
-    else:
-        return Serializer(pymodaq_object).to_b64_string() # will raise a proper error if the object
-    #is not serializable
+ser_factory = SerializableFactory()
 
 
 ## this form below is to be compatible with python <= 3.10
@@ -36,22 +26,33 @@ for klass in ser_factory.get_serializables()[1:]:
 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."""
+    """Serialize (binary) a pymodaq object, if it is not JSON compatible.
+
+    If an object is JSON serializable, we can send it as a value to the JSON
+    encoder and do not need a binary value.
+    Otherwise, the JSON value is None and the serialized object is returned.
+
+    :param pymodaq_object: the object which shall be sent via LECO protocol.
+    :return: tuple of the JSON value and a list of additional payload frames.
+    """
     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."
-        )
+    return None, [SerializableFactory().get_apply_serializer(pymodaq_object)]
+
 
 
 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."""
+    """Create a dictionary of data parameters and of additional payload to send.
+
+    This method prepares arguments for PyLECO's :meth:`Communicator.ask_rpc` method.
+    In order to send a binary value as an argument `data_key` for a method, the
+    argument has to be None, which is JSON describable.
+    The binary data has to be sent via the `additional_payload` parameter.
+    If the data can be sent as JSON, it is sent directly (`data_key`) and no
+    additional frames are sent.
+    """
     d, b = binary_serialization(pymodaq_object=pymodaq_object)
     return {data_key: d, "additional_payload": b}
 
@@ -69,6 +70,5 @@ def start_coordinator():
                 run_coordinator()
             else:
                 logger.info('Coordinator already running')
-    except ConnectionRefusedError as e:
+    except ConnectionRefusedError:
         run_coordinator()
-

pymodaq/utils/managers/batchscan_manager.py

@@ -4,6 +4,7 @@ import sys
 from typing import List
 
 from qtpy import QtWidgets, QtCore
+from qtpy.QtWidgets import QMessageBox, QDialog, QDialogButtonBox
 
 from pymodaq_utils.logger import set_logger, get_module_name
 from pymodaq_utils import config as config_mod
@@ -59,13 +60,13 @@ class BatchManager(ParameterManager):
         self.batch_path = path
 
         if msgbox:
-            msgBox = QtWidgets.QMessageBox()
+            msgBox = QMessageBox()
             msgBox.setText("Scan Batch Manager?")
             msgBox.setInformativeText("What do you want to do?")
-            cancel_button = msgBox.addButton(QtWidgets.QMessageBox.Cancel)
-            new_button = msgBox.addButton("New", QtWidgets.QMessageBox.ActionRole)
-            modify_button = msgBox.addButton('Modify', QtWidgets.QMessageBox.AcceptRole)
-            msgBox.setDefaultButton(QtWidgets.QMessageBox.Cancel)
+            cancel_button = msgBox.addButton(QMessageBox.StandardButton.Cancel)
+            new_button = msgBox.addButton("New", QMessageBox.ButtonRole.AcceptRole)
+            modify_button = msgBox.addButton('Modify', QMessageBox.ButtonRole.AcceptRole)
+            msgBox.setDefaultButton(QMessageBox.StandardButton.Cancel)
             ret = msgBox.exec()
 
             if msgBox.clickedButton() == new_button:
@@ -154,16 +155,16 @@ class BatchManager(ParameterManager):
     def show_tree(self):
 
 
-        dialog = QtWidgets.QDialog()
+        dialog = QDialog()
         dialog.setLayout(QtWidgets.QVBoxLayout())
 
         widget_all_settings = QtWidgets.QWidget()
 
         dialog.layout().addWidget(widget_all_settings)
-        buttonBox = QtWidgets.QDialogButtonBox(parent=dialog)
-        buttonBox.addButton('Save', buttonBox.AcceptRole)
+        buttonBox = QDialogButtonBox(parent=dialog)
+        buttonBox.addButton("Save", QDialogButtonBox.ButtonRole.AcceptRole)
         buttonBox.accepted.connect(dialog.accept)
-        buttonBox.addButton('Cancel', buttonBox.RejectRole)
+        buttonBox.addButton("Cancel", QDialogButtonBox.ButtonRole.RejectRole)
         buttonBox.rejected.connect(dialog.reject)
 
         dialog.layout().addWidget(buttonBox)
@@ -186,11 +187,11 @@ class BatchManager(ParameterManager):
 
         res = dialog.exec()
 
-        if res == dialog.Accepted:
+        if res == QDialog.DialogCode.Accepted:
             ioxml.parameter_to_xml_file(
                 self.settings, self.batch_path.joinpath(self.settings.child('filename').value()))
 
-        return res == dialog.Accepted
+        return res == QDialog.DialogCode.Accepted
 
     def set_scanner_settings(self, settings_tree: QtWidgets.QWidget):
         while True: