pymodaq 4.1.5__py3-none-any.whl → 4.2.1__py3-none-any.whl

pymodaq/utils/leco/daq_move_LECODirector.py

@@ -0,0 +1,172 @@
+"""
+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`
+
+"""
+
+from typing import Union
+
+from pymodaq.control_modules.move_utility_classes import (DAQ_Move_base, comon_parameters_fun, main,
+                                                          DataActuatorType, DataActuator)
+
+from pymodaq.utils.daq_utils import ThreadCommand
+from pymodaq.utils.parameter import Parameter
+
+from pymodaq.utils.leco.leco_director import LECODirector, leco_parameters
+from pymodaq.utils.leco.director_utils import ActuatorDirector
+from pymodaq.utils.tcp_ip.serializer import DeSerializer
+
+
+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: ActuatorDirector
+
+    is_multiaxes = False
+    axes_names = []
+    params_client = []  # parameters of a client grabber
+    data_actuator_type = DataActuatorType['float']  # DataActuatorType['DataActuator']
+
+    message_list = LECODirector.message_list + ["move_abs", 'move_home', 'move_rel',
+                                                'get_actuator_value', 'stop_motion', 'position_is',
+                                                'move_done']
+    socket_types = ["ACTUATOR"]
+    params = [
+    ] + comon_parameters_fun(is_multiaxes=is_multiaxes, axes_names=axes_names) + leco_parameters
+
+    def __init__(self, parent=None, params_state=None, **kwargs) -> None:
+        super().__init__(parent=parent,
+                         params_state=params_state, **kwargs)
+        self.register_rpc_methods((
+            self.set_info,
+            self.set_position,
+            self.set_move_done,
+            self.set_x_axis,
+            self.set_y_axis,
+        ))
+
+        # copied, I think it is good:
+        self.settings.child('bounds').hide()
+        self.settings.child('scaling').hide()
+        self.settings.child('epsilon').setValue(1)
+
+    def commit_settings(self, param) -> None:
+        self.commit_leco_settings(param=param)
+
+    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.child("actor_name").value()
+        self.controller = self.ini_stage_init(  # type: ignore
+            old_controller=controller,
+            new_controller=ActuatorDirector(actor=actor_name, communicator=self.communicator),
+            )
+        try:
+            self.controller.set_remote_name(self.communicator.full_name)  # type: ignore
+        except TimeoutError:
+            print("Timeout setting remote name.")  # TODO change to real logging
+        # self.settings.child('infos').addChildren(self.params_client)
+
+        self.settings.child('units').hide()
+        self.settings.child('epsilon').hide()
+
+        self.status.info = "LECODirector"
+        self.status.controller = self.controller
+        self.status.initialized = True
+        return self.status
+
+    def move_abs(self, position: DataActuator) -> None:
+        position = self.check_bound(position)
+        position = self.set_position_with_scaling(position)
+
+        self.controller.move_abs(position=position)
+
+        self.target_value = 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)
+        self.controller.move_rel(position=position)
+
+    def move_home(self):
+        self.controller.move_home()
+
+    def get_actuator_value(self) -> DataActuator:
+        """
+        Get the current hardware position with scaling conversion given by
+        `get_position_with_scaling`.
+
+        See Also
+        --------
+            daq_move_base.get_position_with_scaling, daq_utils.ThreadCommand
+        """
+        self.controller.set_remote_name(self.communicator.full_name)  # to ensure communication
+        self.controller.get_actuator_value()
+        return self._current_value
+
+    def stop_motion(self) -> None:
+        """
+            See Also
+            --------
+            daq_move_base.move_done
+        """
+        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()
+        else:
+            pos = DataActuator(data=position)
+        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)
+        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)
+        self.emit_status(ThreadCommand('move_done', [pos]))
+
+    def set_x_axis(self, data, label: str = "", units: str = "") -> None:
+        raise NotImplementedError("where is it handled?")
+
+    def set_y_axis(self, data, label: str = "", units: str = "") -> None:
+        raise NotImplementedError("where is it handled?")
+
+
+if __name__ == '__main__':
+    main(__file__)

pymodaq/utils/leco/daq_xDviewer_LECODirector.py

@@ -0,0 +1,170 @@
+
+from typing import Union
+
+from easydict import EasyDict as edict
+
+from pymodaq.control_modules.viewer_utility_classes import DAQ_Viewer_base, comon_parameters, main
+
+from pymodaq.utils.daq_utils import ThreadCommand, getLineInfo
+from pymodaq.utils.parameter import Parameter
+from pymodaq.utils.tcp_ip.serializer import DeSerializer
+
+from pymodaq.utils.leco.leco_director import LECODirector, leco_parameters
+from pymodaq.utils.leco.director_utils import DetectorDirector
+
+
+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 = []
+
+    message_list = LECODirector.message_list + ["Quit", "Send Data 0D", "Send Data 1D",
+                                                "Send Data 2D", "Send Data ND",
+                                                "Status", "Done", "Server Closed",
+                                                "Info", "Infos", "Info_xml", 'x_axis', 'y_axis']
+    socket_types = ["GRABBER"]
+    params = [
+    ] + comon_parameters + leco_parameters
+
+    def __init__(self, parent=None, params_state=None, grabber_type: str = "0D", **kwargs) -> None:
+        super().__init__(parent=parent, params_state=params_state, **kwargs)
+        self.register_rpc_methods((
+            self.set_x_axis,
+            self.set_y_axis,
+            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
+
+    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
+        """
+        self.status.update(edict(initialized=False, info="", x_axis=None, y_axis=None,
+                                 controller=None))
+        actor_name = self.settings.child("actor_name").value()
+        self.controller = self.ini_detector_init(  # type: ignore
+            old_controller=controller,
+            new_controller=DetectorDirector(actor=actor_name, communicator=self.communicator),
+            )
+        self.controller.set_remote_name(self.communicator.full_name)  # type: ignore
+        try:
+            # self.settings.child(('infos')).addChildren(self.params_GRABBER)
+
+            # init axes from image , here returns only None values (to tricky to di it with the
+            # server and not really necessary for images anyway)
+            self.x_axis = self.get_xaxis()
+            self.y_axis = self.get_yaxis()
+            self.status.x_axis = self.x_axis
+            self.status.y_axis = self.y_axis
+            self.status.initialized = True
+            return self.status
+
+        except Exception as e:
+            self.status.info = getLineInfo() + str(e)
+            self.status.initialized = False
+            return self.status
+
+    def get_xaxis(self):
+        """
+            Obtain the horizontal axis of the image.
+
+            Returns
+            -------
+            1D numpy array
+                Contains a vector of integer corresponding to the horizontal camera pixels.
+        """
+        pass
+        return self.x_axis
+
+    def get_yaxis(self):
+        """
+            Obtain the vertical axis of the image.
+
+            Returns
+            -------
+            1D numpy array
+                Contains a vector of integer corresponding to the vertical camera pixels.
+        """
+        pass
+        return self.y_axis
+
+    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
+        """
+        try:
+            self.ind_grabbed = 0  # to keep track of the current image in the average
+            self.Naverage = Naverage
+            self.controller.set_remote_name(self.communicator.full_name)
+            self.controller.send_data(grabber_type=self.grabber_type)
+
+        except Exception as e:
+            self.emit_status(ThreadCommand('Update_Status', [getLineInfo() + str(e), "log"]))
+
+    def stop(self):
+        """
+            not implemented.
+        """
+        pass
+        return ""
+
+    # Methods for RPC calls
+    def set_x_axis(self, data, label: str = "", units: str = ""):
+        # TODO make to work
+        self.x_axis = dict(data=data, label=label, units=units)
+        self.emit_x_axis()
+
+    def set_y_axis(self, data, label: str = "", units: str = ""):
+        # TODO make to work
+        self.y_axis = dict(data=data, label=label, units=units)
+        self.emit_y_axis()
+
+    def set_data(self, data: Union[list, str]) -> None:
+        """
+        Set the grabbed data signal.
+
+        corresponds to the "data_ready" signal
+
+        :param data: If None, look for the additional object
+        """
+        if isinstance(data, str):
+            deserializer = DeSerializer.from_b64_string(data)
+            dte = deserializer.dte_deserialization()
+            self.dte_signal.emit(dte)
+        else:
+            raise NotImplementedError("Not implemented to set a list of values.")
+
+
+if __name__ == '__main__':
+    main(__file__)

pymodaq/utils/leco/desktop.ini

@@ -0,0 +1,2 @@
+[LocalizedFileNames]
+Command Prompt.lnk=@%SystemRoot%\system32\shell32.dll,-22022

pymodaq/utils/leco/director_utils.py

@@ -0,0 +1,58 @@
+"""
+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.utils.parameter.utils as putils
+from pymodaq.utils.parameter import Parameter, ioxml
+from pymodaq.control_modules.move_utility_classes import DataActuator
+from pymodaq.utils.leco.utils import serialize_object
+
+
+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="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?)
+        self.set_info_str(path=putils.get_param_path(param)[2:],
+                          param_dict_str=ioxml.parameter_to_xml_string(param).decode())
+
+    def set_info_str(self, path: List[str], param_dict_str: str) -> None:
+        self.ask_rpc(method="sef_info", path=path, param_dict_str=param_dict_str)
+
+
+class DetectorDirector(GenericDirector):
+    def send_data(self, grabber_type: str = "") -> None:
+        self.ask_rpc("send_data", grabber_type=grabber_type)
+
+
+class ActuatorDirector(GenericDirector):
+    def move_abs(self, position: Union[float, DataActuator]) -> None:
+        self.ask_rpc("move_abs", position=serialize_object(position))
+
+    def move_rel(self, position: Union[float, DataActuator]) -> None:
+        self.ask_rpc("move_rel", position=serialize_object(position))
+
+    def move_home(self) -> None:
+        self.ask_rpc("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("get_actuator_value")
+
+    def stop_motion(self,) -> None:
+        # not implemented in DAQ_Move!
+        self.ask_rpc("stop_motion")

pymodaq/utils/leco/leco_director.py

@@ -0,0 +1,88 @@
+
+import random
+
+from typing import Callable, Sequence, List
+
+import pymodaq.utils.parameter.utils as putils
+# object used to send info back to the main thread:
+from pymodaq.utils.daq_utils import ThreadCommand
+from pymodaq.utils.parameter import Parameter
+
+from pymodaq.utils.leco.director_utils import GenericDirector
+from pymodaq.utils.leco.pymodaq_listener import PymodaqListener
+
+
+leco_parameters = [
+    {'title': 'Actor name:', 'name': 'actor_name', 'type': 'str', 'value': "actor_name",
+     'text': 'Name of the actor plugin to communicate with.'},
+]
+
+
+class LECODirector:
+    """
+    This is a mixin for a Control module to direct another, remote module (analogous to TCP Server).
+
+        ================= ==============================
+        **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
+    """
+    message_list = ["Quit", "Status", "Done", "Server Closed", "Info", "Infos", "Info_xml",
+                    "move_abs", 'move_home', 'move_rel', 'get_actuator_value', 'stop_motion',
+                    'position_is', 'move_done',
+                    ]
+    socket_types: List[str]
+
+    controller: GenericDirector
+    settings: Parameter
+
+    def __init__(self, **kwargs) -> None:
+        super().__init__(**kwargs)
+
+        name = f'{self._title}_{random.randrange(0, 10000)}_director'
+        # TODO use the same Listener instance as the LECOActorModule
+        self.listener = PymodaqListener(name=name)
+        self.listener.start_listen()
+        self.communicator = self.listener.get_communicator()
+        self.register_rpc_methods((
+            self.set_info,
+        ))
+
+    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: Parameter) -> None:
+        raise NotImplementedError
+
+    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:
+        self.listener.stop_listen()
+
+    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_info(self, path: List[str], param_dict_str: str) -> None:
+        self.emit_status(ThreadCommand("set_info", attribute=[path, param_dict_str]))