pymodaq 5.1.6__py3-none-any.whl

pymodaq/utils/leco/daq_move_LECODirector.py

@@ -0,0 +1,217 @@
+"""
+LECO Director instrument plugin are to be used to communicate (and control) remotely real
+instrument plugin through TCP/IP using the LECO Protocol
+
+For this to work a coordinator must be instantiated can be done within the dashboard or directly
+running: `python -m pyleco.coordinators.coordinator`
+
+"""
+
+import numpy as np
+
+from typing import Optional, Union
+
+from pymodaq.control_modules.move_utility_classes import (DAQ_Move_base, comon_parameters_fun, main,
+                                                          DataActuatorType, DataActuator)
+from pymodaq.control_modules.thread_commands import ThreadStatus, ThreadStatusMove
+
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_utils.utils import find_dict_in_list_from_key_val
+from pymodaq_utils.serialize.factory import SerializableFactory
+from pymodaq_gui.parameter import Parameter
+
+from pymodaq.utils.leco.leco_director import (LECODirector, leco_parameters, DirectorCommands,
+                                              DirectorReceivedCommands)
+from pymodaq.utils.leco.director_utils import ActuatorDirector
+
+from pymodaq_utils.logger import set_logger, get_module_name
+
+logger = set_logger(get_module_name(__file__))
+
+
+class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
+    """A control module, which in the dashboard, allows to control a remote Move module.
+
+        ================= ==============================
+        **Attributes**      **Type**
+        *command_server*    instance of Signal
+        *x_axis*            1D numpy array
+        *y_axis*            1D numpy array
+        *data*              double precision float array
+        ================= ==============================
+
+        See Also
+        --------
+        utility_classes.DAQ_TCP_server
+    """
+    settings: Parameter
+    controller: Optional[ActuatorDirector]
+    _axis_names = ['']
+    _controller_units = ['']
+    _epsilon = 1
+
+    params_client = []  # parameters of a client grabber
+    data_actuator_type = DataActuatorType.DataActuator
+    params = comon_parameters_fun(axis_names=_axis_names, epsilon=_epsilon) + leco_parameters
+
+    for param_name in ('multiaxes', 'units', 'epsilon', 'bounds', 'scaling'):
+        param_dict = find_dict_in_list_from_key_val(params, 'name', param_name)
+        if param_dict is not None:
+            param_dict['visible'] = False
+
+    def __init__(
+        self, parent=None, params_state=None, host: Optional[str] = None, port: Optional[int] = None, **kwargs
+    ) -> None:
+        DAQ_Move_base.__init__(self, parent=parent, params_state=params_state)
+        if host is not None:
+            self.settings["host"] = host
+        if port is not None:
+            self.settings["port"] = port
+        LECODirector.__init__(self, host=self.settings["host"], port=self.settings["port"])
+        self.register_rpc_methods((
+            self.set_units,  # to set units accordingly to the one of the actor
+        ))
+
+        self.register_binary_rpc_methods((
+            self.send_position,  # to display the actor position
+            self.set_move_done,  # to set the move as done
+        ))
+        self.start_timer()
+        # To distinguish how to encode positions, it needs to now if it deals
+        # with a json-accepting or a binary-accepting actuator
+        # It is set to False by default. It then use the first received message
+        # from the actuator that should contain its position to decide if it
+        # need to switch to json.
+        self.json = False
+
+    def ini_stage(self, controller=None):
+        """Actuator communication initialization
+
+        Parameters
+        ----------
+        controller: (object)
+            custom object of a PyMoDAQ plugin (Slave case). None if only one actuator by controller
+            (Master case)
+
+        Returns
+        -------
+        info: str
+        initialized: bool
+            False if initialization failed otherwise True
+        """
+        actor_name = self.settings["actor_name"]
+
+        if self.is_master:
+            self.controller = ActuatorDirector(actor=actor_name, communicator=self.communicator)
+            try:
+                self.controller.set_remote_name(self.communicator.full_name)
+            except TimeoutError:
+                logger.warning("Timeout setting remote name.")
+        else:
+            self.controller = controller
+
+        self.json = False
+        # send a command to the Actor whose name is actor_name to send its settings
+        self.controller.get_settings()
+
+        info = f"LECODirector: {self._title} is initialized"
+        initialized = True
+        return info, initialized
+
+    def move_abs(self, position: DataActuator) -> None:
+        position = self.check_bound(position)
+        position = self.set_position_with_scaling(position)
+        self.target_value = position
+        if self.json:
+            # if it's 0D, just send the position as a scalar
+            if hasattr(self, 'shape') and self.shape == ():
+                position = position.value(self.axis_unit)
+            else:
+                # Until the GUI allows for it (next line), we send the single value repeated
+                # position = [data.m_as(self.axis_unit) for data in position.quantities]
+                position = np.full(self.shape, position.value(self.axis_unit)).tolist()
+        self.controller.move_abs(position=position)
+
+    def move_rel(self, position: DataActuator) -> None:
+        position = self.check_bound(self.current_value + position) - self.current_value  # type: ignore  # noqa
+        self.target_value = position + self.current_value
+
+        position = self.set_position_relative_with_scaling(position)
+        if self.json:
+            # if it's 0D, just send the position as a scalar
+            if hasattr(self, 'ndim') and self.shape == ():
+                position = position.value(self.axis_unit)
+            else:
+                # Until the GUI allows for it (next line), we send the single value repeated
+                #position = [data.m_as(self.axis_unit) for data in position.quantities]
+                position = np.full(self.shape, position.value(self.axis_unit)).tolist()
+
+        self.controller.move_rel(position=position)
+
+    def move_home(self):
+        self.controller.move_home()
+
+    def get_actuator_value(self) -> DataActuator:
+        """ Get the current hardware value """
+        self.controller.get_actuator_value()
+        return self._current_value
+
+    def stop_motion(self) -> None:
+        """
+        """
+        self.controller.stop_motion()
+
+    # Methods accessible via remote calls
+    def _set_position_value(
+        self, data: Union[dict, list, str, float, None], additional_payload=None
+    ) -> DataActuator:
+
+        # This is the first received message, if position is set then
+        # it's included in the json payload and the director should
+        # usejson
+
+
+        if data is not None:
+            position = data.get('position', [])
+
+            self.shape = np.array(position).shape
+            position = [np.atleast_1d(position)]
+
+            pos = DataActuator(data=position)
+            self.json = True
+        elif additional_payload:
+            pos = SerializableFactory().get_apply_deserializer(additional_payload[0])
+        else:
+            raise ValueError("No position given")
+        pos = self.get_position_with_scaling(pos)  # type: ignore
+        self._current_value = pos
+        return pos
+
+    def send_position(self, data: Union[dict, list, str, float, None], additional_payload=None) -> None:
+        pos = self._set_position_value(data=data, additional_payload=additional_payload)
+        self.emit_status(ThreadCommand(ThreadStatusMove.GET_ACTUATOR_VALUE, pos))
+
+    def set_move_done(self, data: Union[dict, list, str, float, None], additional_payload=None) -> None:
+        pos = self._set_position_value(data=data, additional_payload=additional_payload)
+        self.emit_status(ThreadCommand(ThreadStatusMove.MOVE_DONE, pos))
+
+    def set_units(self, units: str, additional_payload=None) -> None:
+        if units not in self.axis_units:
+            self.axis_units.append(units)
+        self.axis_unit = units
+
+    def set_director_settings(self, settings: bytes):
+        """ Get the content of the actor settings to pe populated in this plugin
+        'settings_client' parameter
+
+        Then set the plugin units from this information"""
+        super().set_director_settings(settings)
+        self.axis_unit = self.settings['settings_client', 'units']
+
+    def close(self) -> None:
+        """ Clear the content of the settings_clients setting"""
+        super().close()
+
+
+if __name__ == '__main__':
+    main(__file__, init=False)

pymodaq/utils/leco/daq_xDviewer_LECODirector.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+from typing import Optional, Union
+
+from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base, comon_parameters, main
+from pymodaq.control_modules.thread_commands import ThreadStatus, ThreadStatusViewer
+from pymodaq.utils.data import DataFromPlugins, Axis
+from pymodaq_data import DataToExport
+from pymodaq_utils.serialize.factory import SerializableFactory
+from pymodaq_utils.utils import ThreadCommand, getLineInfo
+
+from pymodaq.utils import data  # for serialization factory registration  # noqa: F401
+from pymodaq_gui.parameter import Parameter
+
+from pymodaq.utils.leco.leco_director import LECODirector, leco_parameters
+from pymodaq.utils.leco.director_utils import DetectorDirector
+from pymodaq_utils.logger import set_logger, get_module_name
+
+import numpy as np
+
+logger = set_logger(get_module_name(__file__))
+
+
+class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
+    """A control module, which in the dashboard, allows to control a remote Viewer module.
+
+    This is the base class for the viewer LECO director modules.
+    """
+
+    settings: Parameter
+    controller: DetectorDirector
+
+    params_GRABBER = []
+
+    socket_types = ["GRABBER"]
+    params = comon_parameters + leco_parameters
+    live_mode_available = True
+
+    def __init__(
+        self,
+        parent=None,
+        params_state=None,
+        grabber_type: str = "0D",
+        host: Optional[str] = None,
+        port: Optional[int] = None,
+        **kwargs,
+    ) -> None:
+        DAQ_Viewer_base.__init__(self, parent=parent, params_state=params_state)
+        if host is not None:
+            self.settings["host"] = host
+        if port is not None:
+            self.settings["port"] = port
+        LECODirector.__init__(self, host=self.settings["host"], port=self.settings["port"])
+
+        self.register_binary_rpc_methods((self.set_data,))
+
+        self.client_type = "GRABBER"
+        self.x_axis = None
+        self.y_axis = None
+        self.data = None
+        self.grabber_type = grabber_type
+        self.ind_data = 0
+        self.data_mock = None
+        self.start_timer()
+
+    def ini_detector(self, controller=None):
+        """
+            | Initialisation procedure of the detector updating the status dictionary.
+            |
+            | Init axes from image , here returns only None values (to tricky to di it with the
+              server and not really necessary for images anyway)
+
+            See Also
+            --------
+            utility_classes.DAQ_TCP_server.init_server, get_xaxis, get_yaxis
+        """
+
+        actor_name = self.settings["actor_name"]
+        if self.is_master:
+            self.controller = DetectorDirector(actor=actor_name,
+                                               communicator=self.communicator)
+            try:
+                self.controller.set_remote_name(self.communicator.full_name)
+            except TimeoutError:
+                logger.warning("Timeout setting remote name.")
+        else:
+            self.controller = controller
+
+        self.controller.get_settings()
+
+        initialized = True
+        info = 'Viewer Director ready'
+        return info, initialized
+
+    def grab_data(self, Naverage=1, **kwargs):
+        """
+            Start new acquisition.
+            Grabbed indice is used to keep track of the current image in the average.
+
+            ============== ========== ==============================
+            **Parameters**   **Type**  **Description**
+
+            *Naverage*        int       Number of images to average
+            ============== ========== ==============================
+
+            See Also
+            --------
+            utility_classes.DAQ_TCP_server.process_cmds
+        """
+
+        self.ind_grabbed = 0  # to keep track of the current image in the average
+        self.Naverage = Naverage
+        if kwargs.get('live', False):
+            self.controller.send_data_grab()
+        else:
+            self.controller.send_data_snap()
+
+    def stop(self):
+        """Stop grabbing."""
+        self.controller.stop_grab()
+
+    def set_data(self, data: Union[dict,list, str, float, None],
+                 additional_payload: Optional[list[bytes]] = None) -> None:
+        """
+        Set the grabbed data signal.
+
+        corresponds to the "data_ready" signal
+
+        :param data: If None, look for the additional object
+        """
+        if additional_payload:
+            dte = SerializableFactory().get_apply_deserializer(additional_payload[0])
+        elif data is not None:
+            axes = []
+            labels = []
+            multichannel = False
+            if isinstance(data, dict):
+                axes = [
+                    Axis( label=axis.get('label', ''),
+                          units=axis.get('units', ''),
+                          data=np.array(axis.get('data', [])),
+                          index=ind
+                    ) for ind, axis in enumerate(data.get('axes', []))
+                ]
+                labels = data.get('labels', [])
+                multichannel = data.get('multichannel', False)
+                data = data.get('data', [])
+            if multichannel:
+                # data[0] may fail if data is empty, but it shouldn't happen
+                ndim = np.array(data[0]).ndim
+                data = [np.atleast_1d(d) for d in data]
+            else:
+                ndim = np.array(data).ndim
+                data = [np.atleast_1d(data)]
+
+            dfp = DataFromPlugins(self.controller.actor, data=data, axes=axes[:ndim], labels=labels)
+            dte = DataToExport('Copy', data=[dfp])
+        else:
+            raise ValueError("Can't set_data when data is None")
+        self.dte_signal.emit(dte)
+
+
+if __name__ == '__main__':
+    main(__file__, init=False)

pymodaq/utils/leco/director_utils.py

@@ -0,0 +1,74 @@
+"""
+Utils for the Director Modules
+
+These directors correspond to the PymodaqListener
+"""
+
+from typing import Optional, Union, List
+
+from pyleco.directors.director import Director
+
+import pymodaq_gui.parameter.utils as putils
+from pymodaq_gui.parameter import Parameter, ioxml
+from pymodaq.utils.data import DataActuator
+from pymodaq.utils.leco.utils import binary_serialization_to_kwargs, SerializableFactory
+from pymodaq.utils.leco.rpc_method_definitions import GenericMethods, MoveMethods, ViewerMethods
+
+from pymodaq_gui.parameter.utils import ParameterWithPath
+
+
+
+class GenericDirector(Director):
+    """Director helper to control some Module remotely."""
+
+    def set_remote_name(self, name: Optional[str] = None):
+        """Set the remote name of the Module (i.e. where it should send responses to)."""
+        self.ask_rpc(method=GenericMethods.SET_REMOTE_NAME, name=name or self.communicator.name)
+
+    def set_info(self, param: Parameter):
+        # It removes the first two parts (main_settings and detector_settings?)
+        pwp = ParameterWithPath(param, putils.get_param_path(param)[2:])
+        self.ask_rpc(method=GenericMethods.SET_INFO,
+                     **binary_serialization_to_kwargs(pwp, data_key='parameter'))
+
+    def get_settings(self,) -> None:
+        self.ask_rpc(GenericMethods.GET_SETTINGS)
+
+
+class DetectorDirector(GenericDirector):
+    def send_data_grab(self) -> None:
+        self.ask_rpc(ViewerMethods.GRAB)
+
+    def send_data_snap(self) -> None:
+        self.ask_rpc(ViewerMethods.SNAP)
+
+    def stop_grab(self) -> None:
+        self.ask_rpc(ViewerMethods.STOP)
+
+
+class ActuatorDirector(GenericDirector):
+    def move_abs(self, position: Union[list, float, DataActuator]) -> None:
+        self.ask_rpc(
+            MoveMethods.MOVE_ABS, **binary_serialization_to_kwargs(position, data_key="position")
+        )
+
+    def move_rel(self, position: Union[list, float, DataActuator]) -> None:
+        self.ask_rpc(
+            MoveMethods.MOVE_REL, **binary_serialization_to_kwargs(position, data_key="position")
+        )
+
+    def move_home(self) -> None:
+        self.ask_rpc(MoveMethods.MOVE_HOME)
+
+    def get_actuator_value(self) -> None:
+        """Request that the actuator value is sent later on.
+
+        Later the `set_data` method will be called.
+        """
+        # according to DAQ_Move, this supersedes "check_position"
+        self.ask_rpc(MoveMethods.GET_ACTUATOR_VALUE)
+
+    def stop_motion(self,) -> None:
+        # not implemented in DAQ_Move!
+        self.ask_rpc(MoveMethods.STOP_MOTION)
+

pymodaq/utils/leco/leco_director.py

@@ -0,0 +1,166 @@
+
+import random
+
+from pyleco.core import COORDINATOR_PORT
+from pymodaq_utils.enums import StrEnum
+from typing import Callable, cast, Sequence, List, Optional, Union
+
+from pyleco.json_utils.errors import JSONRPCError, RECEIVER_UNKNOWN
+import pymodaq_gui.parameter.utils as putils
+from pymodaq_utils.config import Config
+# object used to send info back to the main thread:
+from pymodaq_utils.utils import ThreadCommand
+from pymodaq_gui.parameter import Parameter
+from pymodaq_gui.parameter import ioxml
+from pymodaq_gui.parameter.utils import ParameterWithPath
+from qtpy.QtCore import QTimer
+
+from pymodaq.utils.leco.director_utils import GenericDirector
+from pymodaq.utils.leco.pymodaq_listener import PymodaqListener
+from pymodaq.utils.leco.rpc_method_definitions import GenericDirectorMethods, MoveDirectorMethods
+from pymodaq_utils.serialize.factory import SerializableFactory
+from pymodaq.control_modules.thread_commands import ThreadStatus, ThreadStatusMove
+
+config = Config()
+
+class DirectorCommands(StrEnum):
+    SET_SETTINGS = GenericDirectorMethods.SET_DIRECTOR_SETTINGS
+    SET_INFO = GenericDirectorMethods.SET_DIRECTOR_INFO
+
+    SEND_POSITION = MoveDirectorMethods.SEND_POSITION  # to display the actor position
+    SET_MOVE_DONE = MoveDirectorMethods.SET_MOVE_DONE
+    SET_UNITS = MoveDirectorMethods.SET_UNITS  # to set units accordingly to the one of the actor
+
+
+class DirectorReceivedCommands(StrEnum):
+    MOVE_DONE = ThreadStatusMove.MOVE_DONE
+    GET_ACTUATOR_VALUE = ThreadStatusMove.GET_ACTUATOR_VALUE
+
+config = Config()
+
+leco_parameters = [
+    {'title': 'Actor name:', 'name': 'actor_name', 'type': 'str', 'value': "actor_name",
+     'tip': 'Name of the actor plugin to communicate with.'},
+    {'title': 'Coordinator Host:', 'name': 'host', 'type': 'str', 'value': config('network', "leco-server", "host")},
+    {'title': 'Coordinator Port:', 'name': 'port', 'type': 'int', 'value': config('network', "leco-server", "port")},
+    {'title': 'Settings PyMoDAQ Client:', 'name': 'settings_client', 'type': 'group', 'children': []},
+]
+
+
+class LECODirector:
+    """
+    This is a mixin for a Control module to direct another, remote module (analogous to TCP Server).
+
+
+    """
+
+    controller: GenericDirector
+    settings: Parameter
+    _title: str
+
+    def __init__(self, host: str = 'localhost', port : int = COORDINATOR_PORT, **kwargs) -> None:
+
+        name = f'{self._title}_{random.randrange(0, 10000)}_director'
+
+        self.listener = PymodaqListener(name=name, host=host, port=port)
+        self.listener.start_listen()
+
+        self.communicator = self.listener.get_communicator()
+
+        #registering rpc methods common to all Directors
+        self.register_rpc_methods((
+            self.set_director_settings,
+        ))
+        self.register_binary_rpc_methods((
+            self.set_director_info,
+        ))
+
+    def register_binary_rpc_methods(self, methods: Sequence[Callable]) -> None:
+        for method in methods:
+            self.listener.register_binary_rpc_method(method, accept_binary_input=True)
+
+    def register_rpc_methods(self, methods: Sequence[Callable]) -> None:
+        for method in methods:
+            self.communicator.register_rpc_method(method=method)
+
+    def commit_settings(self, param) -> None:
+        self.commit_leco_settings(param=param)
+
+    def commit_leco_settings(self, param: Parameter) -> None:
+        if param.name() == "actor_name":
+            self.controller.actor = param.value()
+        elif param.name() in putils.iter_children(self.settings.child('settings_client'), []):
+            self.controller.set_info(param=param)
+
+    def close(self) -> None:
+        """ Clear the content of the settings_clients setting"""
+        self.settings.child('settings_client').clearChildren()
+        self.listener.stop_listen()
+
+    def start_timer(self) -> None:
+        """To be called in child classes."""
+        self.timer = QTimer()
+        self.timer.timeout.connect(self.check_actor_connection)
+        try:
+            # cast is used by the type checker to infer the returned type (when many are possible)
+            timeout = cast(int, config("network", "leco-server", "heartbeat-timeout"))
+        except KeyError:
+            timeout = 1000
+        self.timer.start(timeout)  # in milli seconds
+
+    def check_actor_connection(self) -> None:
+        try:
+            self.controller.ask_rpc("pong", timeout=0.1)
+        except JSONRPCError as exc:
+            if exc.rpc_error.code == RECEIVER_UNKNOWN.code:
+                self.emit_status(ThreadCommand(ThreadStatus.UPDATE_UI, "do_init", args=[False]))
+            else:
+                self.emit_status(
+                    ThreadCommand(
+                        ThreadStatus.UPDATE_STATUS,
+                        f"Connection error to actor: {exc.rpc_error.message}",
+                    )
+                )
+
+    def stop(self):
+        """
+            not implemented.
+        """
+        pass
+        return ""
+
+    def emit_status(self, status: ThreadCommand) -> None:
+        """ Emit the status_sig signal with the given status ThreadCommand back to the main GUI.
+        """
+        super().emit_status(status=status)  # type: ignore
+
+    # Methods accessible via remote calls
+    def set_director_info(self,
+                 parameter: Optional[Union[float, str]],
+                 additional_payload: Optional[List[bytes]] = None,
+                 ) -> None:
+        """ Write the value of a param updated from the actor to here in the
+        Parameter with path: ('move_settings', 'settings_client')
+        """
+        GenericDirectorMethods.SET_DIRECTOR_INFO  # defined here
+        assert additional_payload
+        # cast is used by the type checker to infer the returned type (when many are possible)
+        param = cast(
+            ParameterWithPath, SerializableFactory().get_apply_deserializer(additional_payload[0])
+        )
+
+        try:
+            path = ['settings_client']
+            path.extend(param.path[1:])
+
+            self.settings.child(*path).setValue(param.value())
+        except Exception as e:
+            print(f'could not set the param {param} in the director:\n'
+                  f'{str(e)}')
+
+    def set_director_settings(self, settings: bytes):
+        """ Get the content of the actor settings to pe populated in this plugin
+        'settings_client' parameter"""
+        GenericDirectorMethods.SET_DIRECTOR_INFO  # defined here
+        params = ioxml.XML_string_to_parameter(settings)
+        self.settings.child('settings_client').addChildren(params)