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

pymodaq/utils/leco/daq_xDviewer_LECODirector.py

@@ -1,17 +1,23 @@
 from __future__ import annotations
 from typing import Optional, Union
 
-from easydict import EasyDict as edict
-
 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.serialize.serializer_legacy import DeSerializer
 
 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):
@@ -25,23 +31,27 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
 
     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,
-        ))
-        for method in (
-            self.set_data,
-        ):
-            self.listener.register_binary_rpc_method(method, accept_binary_input=True)
+    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
@@ -50,6 +60,7 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
         self.grabber_type = grabber_type
         self.ind_data = 0
         self.data_mock = None
+        self.start_timer()
 
     def ini_detector(self, controller=None):
         """
@@ -62,54 +73,23 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
             --------
             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
+        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
 
-    def get_yaxis(self):
-        """
-            Obtain the vertical axis of the image.
+        self.controller.get_settings()
 
-            Returns
-            -------
-            1D numpy array
-                Contains a vector of integer corresponding to the vertical camera pixels.
-        """
-        pass
-        return self.y_axis
+        initialized = True
+        info = 'Viewer Director ready'
+        return info, initialized
 
     def grab_data(self, Naverage=1, **kwargs):
         """
@@ -126,35 +106,20 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
             --------
             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"]))
+        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):
-        """
-            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],
-                 additional_payload: Optional[list[bytes]]=None) -> None:
+        """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.
 
@@ -162,15 +127,37 @@ class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
 
         :param data: If None, look for the additional object
         """
-        if isinstance(data, str):
-            deserializer = DeSerializer.from_b64_string(data)
-        elif additional_payload is not None:
-            deserializer = DeSerializer(additional_payload[0])
+        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 NotImplementedError("Not implemented to set a list of values.")
-        dte = deserializer.dte_deserialization()
+            raise ValueError("Can't set_data when data is None")
         self.dte_signal.emit(dte)
 
 
 if __name__ == '__main__':
-    main(__file__)
+    main(__file__, init=False)

pymodaq/utils/leco/director_utils.py

@@ -10,8 +10,12 @@ from pyleco.directors.director import Director
 
 import pymodaq_gui.parameter.utils as putils
 from pymodaq_gui.parameter import Parameter, ioxml
-from pymodaq.control_modules.move_utility_classes import DataActuator
-from pymodaq.utils.leco.utils import serialize_object
+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):
@@ -19,31 +23,42 @@ class GenericDirector(Director):
 
     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)
+        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?)
-        self.set_info_str(path=putils.get_param_path(param)[2:],
-                          param_dict_str=ioxml.parameter_to_xml_string(param).decode())
+        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 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)
+    def get_settings(self,) -> None:
+        self.ask_rpc(GenericMethods.GET_SETTINGS)
 
 
 class DetectorDirector(GenericDirector):
-    def send_data(self, grabber_type: str = "") -> None:
-        self.ask_rpc("send_data", grabber_type=grabber_type)
+    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[float, DataActuator]) -> None:
-        self.ask_rpc("move_abs", position=serialize_object(position))
+    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[float, DataActuator]) -> None:
-        self.ask_rpc("move_rel", position=serialize_object(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("move_home")
+        self.ask_rpc(MoveMethods.MOVE_HOME)
 
     def get_actuator_value(self) -> None:
         """Request that the actuator value is sent later on.
@@ -51,8 +66,9 @@ class ActuatorDirector(GenericDirector):
         Later the `set_data` method will be called.
         """
         # according to DAQ_Move, this supersedes "check_position"
-        self.ask_rpc("get_actuator_value")
+        self.ask_rpc(MoveMethods.GET_ACTUATOR_VALUE)
 
     def stop_motion(self,) -> None:
         # not implemented in DAQ_Move!
-        self.ask_rpc("stop_motion")
+        self.ask_rpc(MoveMethods.STOP_MOTION)
+

pymodaq/utils/leco/leco_director.py

@@ -1,21 +1,49 @@
+
 import random
-from typing import Callable, Sequence, List
 
+from pyleco.core import COORDINATOR_PORT
 from pymodaq_utils.enums import StrEnum
-from typing import Callable, Sequence, List, Optional, Union
+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': []},
 ]
 
 
@@ -23,45 +51,40 @@ 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
+    _title: str
 
-    def __init__(self, **kwargs) -> None:
-        super().__init__(**kwargs)
+    def __init__(self, host: str = 'localhost', port : int = COORDINATOR_PORT, **kwargs) -> None:
 
         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 = 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_info,
+            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: Parameter) -> None:
-        raise NotImplementedError
+    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":
@@ -70,8 +93,35 @@ class LECODirector:
             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.
@@ -85,5 +135,32 @@ class LECODirector:
         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]))
+    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)