pymodaq 5.0.5__py3-none-any.whl → 5.1.0a0__py3-none-any.whl

pymodaq/utils/leco/daq_xDviewer_LECODirector.py

@@ -1,17 +1,20 @@
 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.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
+
+logger = set_logger(get_module_name(__file__))
 
 
 class DAQ_xDViewer_LECODirector(LECODirector, DAQ_Viewer_base):
@@ -25,19 +28,14 @@ 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
+    live_mode_available = True
 
     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,
-        ))
+        DAQ_Viewer_base.__init__(self, parent=parent,
+                                 params_state=params_state)
+        LECODirector.__init__(self, host=self.settings['host'])
         for method in (
             self.set_data,
         ):
@@ -62,54 +60,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)  # type: ignore
+            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,32 +93,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
+        self.controller.set_remote_name(self.communicator.full_name)
+        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()
+        self.controller.stop_grab()
 
     def set_data(self, data: Union[list, str, None],
                  additional_payload: Optional[list[bytes]]=None) -> None:
@@ -162,15 +117,12 @@ 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 is not None:
+            dte = SerializableFactory().get_apply_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__':
-    main(__file__)
+    main(__file__, init=False)

pymodaq/utils/leco/director_utils.py

@@ -10,8 +10,11 @@ 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_gui.parameter.utils import ParameterWithPath
+
 
 
 class GenericDirector(Director):
@@ -23,24 +26,35 @@ class GenericDirector(Director):
 
     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="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('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, grabber_type: str = "") -> None:
+        self.ask_rpc("send_data_grab", grabber_type=grabber_type)
+
+    def send_data_snap(self, grabber_type: str = "") -> None:
+        self.ask_rpc("send_data_snap", grabber_type=grabber_type)
+
+    def stop_grab(self, grabber_type: str = "") -> None:
+        self.ask_rpc("stop_grab", 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))
+        self.ask_rpc(
+            "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))
+        self.ask_rpc(
+            "move_rel", **binary_serialization_to_kwargs(position, data_key="position")
+        )
 
     def move_home(self) -> None:
         self.ask_rpc("move_home")
@@ -56,3 +70,4 @@ class ActuatorDirector(GenericDirector):
     def stop_motion(self,) -> None:
         # not implemented in DAQ_Move!
         self.ask_rpc("stop_motion")
+

pymodaq/utils/leco/leco_director.py

@@ -1,21 +1,42 @@
-import random
-from typing import Callable, Sequence, List
 
+import random
 from pymodaq_utils.enums import StrEnum
 from typing import Callable, Sequence, List, Optional, Union
 
 import pymodaq_gui.parameter.utils as putils
 # object used to send info back to the main thread:
 from pymodaq_utils.utils import ThreadCommand
+from pymodaq.utils.config import Config
 from pymodaq_gui.parameter import Parameter
+from pymodaq_gui.parameter import ioxml
+from pymodaq_gui.parameter.utils import ParameterWithPath
 
 from pymodaq.utils.leco.director_utils import GenericDirector
 from pymodaq.utils.leco.pymodaq_listener import PymodaqListener
+from pymodaq_utils.serialize.factory import SerializableFactory
+from pymodaq.control_modules.thread_commands import ThreadStatusMove
+
+config = Config()
+
+class DirectorCommands(StrEnum):
+    SET_SETTINGS = 'set_settings'
+    SET_INFO = 'set_info'
+
+    SEND_POSITION = 'send_position'  # to display the actor position
+    SET_MOVE_DONE = 'set_move_done'
+    SET_UNITS = '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
 
 
 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': 'Settings PyMoDAQ Client:', 'name': 'settings_client', 'type': 'group', 'children': []},
 ]
 
 
@@ -23,45 +44,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', **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)
         self.listener.start_listen()
+
         self.communicator = self.listener.get_communicator()
+
+        #registering rpc methods common to all Directors
         self.register_rpc_methods((
+            self.set_settings,
+        ))
+        self.register_binary_rpc_methods((
             self.set_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,6 +86,8 @@ 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 stop(self):
@@ -85,5 +103,26 @@ 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_info(self,
+                 parameter: Optional[Union[float, str]],
+                 additional_payload: Optional[List[bytes]] = None,
+                 ) -> None:
+        """ Write the value of a param upfated from the actor to here in the
+        Parameter with path: ('move_settings', 'settings_client')
+        """
+        param: 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_settings(self, settings: bytes):
+        """ Get the content of the actor settings to pe populated in this plugin
+        'settings_client' parameter"""
+        params = ioxml.XML_string_to_parameter(settings)
+        self.settings.child('settings_client').addChildren(params)

pymodaq/utils/leco/pymodaq_listener.py

@@ -3,16 +3,18 @@ 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.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
 
 
@@ -24,15 +26,28 @@ class LECOClientCommands(StrEnum):
 class LECOCommands(StrEnum):
     CONNECT = "ini_connection"
     QUIT = "quit"
+    GET_SETTINGS = 'get_settings'
+    SET_SETTINGS = 'set_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 +68,109 @@ 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_binary_rpc_method(self.set_info, accept_binary_input=True)
+        self.register_rpc_method(self.send_data_grab)
+        self.register_rpc_method(self.send_data_snap)
+        self.register_binary_rpc_method(self.move_abs, accept_binary_input=True)
+        self.register_binary_rpc_method(self.move_rel, accept_binary_input=True)
         self.register_rpc_method(self.move_home)
         self.register_rpc_method(self.get_actuator_value)
         self.register_rpc_method(self.stop_motion)
+        self.register_rpc_method(self.stop_grab)
+        self.register_rpc_method(self.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:
+        param: 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
@@ -182,7 +252,6 @@ class ActorListener(PymodaqListener):
         """Define what the name of the remote for answers is."""
         self.remote_name = name
 
-    # @Slot(ThreadCommand)
     def queue_command(self, command: ThreadCommand) -> None:
         """Queue a command to send it via LECO to the server."""
 
@@ -203,15 +272,7 @@ 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,
@@ -219,52 +280,41 @@ class ActorListener(PymodaqListener):
                 **binary_serialization_to_kwargs(value),
             )
 
-        elif command.command == 'send_info':
-            path = command.attribute['path']  # type: ignore
-            param = command.attribute['param']  # type: ignore
+        elif command.command == LECOCommands.SEND_INFO:
             self.communicator.ask_rpc(
                 receiver=self.remote_name,
                 method="set_info",
-                path=path,
-                param_dict_str=ioxml.parameter_to_xml_string(param).decode())
+                **binary_serialization_to_kwargs(command.attribute, data_key='parameter'))
 
         elif command.command == LECOMoveCommands.POSITION:
-            value = command.attribute[0]  # type: ignore
+            value = command.attribute
+            if isinstance(value, (list, tuple)):
+                value = value[0]  # for backward compatibility with attributes list
             self.communicator.ask_rpc(receiver=self.remote_name,
-                                      method="set_position",
-                                      **binary_serialization_to_kwargs(value, data_key="position"),
+                                      method="send_position",
+                                      **binary_serialization_to_kwargs(pymodaq_object=value, data_key="position"),
                                       )
 
         elif command.command == LECOMoveCommands.MOVE_DONE:
-            value = command.attribute[0]  # type: ignore
+            value = command.attribute
+            if isinstance(value, (list, tuple)):
+                value = value[0]  # for backward compatibility with attributes list
             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.command == LECOMoveCommands.UNITS_CHANGED:
+            units: str = command.attribute
+            self.communicator.ask_rpc(receiver=self.remote_name,
+                                      method="set_units",
+                                      units=units.encode(),
+                                      )
+
+        elif command.command == LECOCommands.SET_SETTINGS:
+            self.communicator.ask_rpc(receiver=self.remote_name,
+                                      method='set_settings',
+                                      settings=command.attribute.decode())
 
         else:
             raise IOError('Unknown TCP client command')