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

pymodaq/utils/leco/pymodaq_listener.py

@@ -0,0 +1,279 @@
+
+try:
+    from enum import StrEnum  # type: ignore
+except ImportError:
+    from enum import Enum
+
+    class StrEnum(str, Enum):
+        pass
+import logging
+from threading import Event
+from typing import Optional, Union, List, Type
+
+from pyleco.core import COORDINATOR_PORT
+from pyleco.utils.listener import Listener, PipeHandler
+from qtpy.QtCore import QObject, Signal  # type: ignore
+
+from pymodaq.utils.daq_utils import ThreadCommand
+from pymodaq.utils.parameter import ioxml
+from pymodaq.utils.tcp_ip.serializer import DataWithAxes, SERIALIZABLE, DeSerializer
+from pymodaq.utils.leco.utils import serialize_object
+
+
+class LECOClientCommands(StrEnum):
+    LECO_CONNECTED = "leco_connected"
+    LECO_DISCONNECTED = "leco_disconnected"
+
+
+class LECOCommands(StrEnum):
+    CONNECT = "ini_connection"
+    QUIT = "quit"
+
+
+class LECOMoveCommands(StrEnum):
+    POSITION = 'position_is'
+    MOVE_DONE = 'move_done'
+
+
+class LECOViewerCommands(StrEnum):
+    DATA_READY = 'data_ready'
+
+
+class ListenerSignals(QObject):
+    cmd_signal = Signal(ThreadCommand)
+    """
+    Possible messages sendable via `cmd_signal`
+        For all modules: Info, Infos, Info_xml, set_info
+
+        For a detector: Send Data 0D, Send Data 1D, Send Data 2D
+
+        For an actuator: move_abs, move_home, move_rel, check_position, stop_motion
+    """
+    # message = Signal(Message)
+
+
+class PymodaqPipeHandler(PipeHandler):
+
+    def __init__(self, name: str, signals: ListenerSignals, **kwargs) -> None:
+        super().__init__(name, **kwargs)
+        self.signals = signals
+
+
+class ActorHandler(PymodaqPipeHandler):
+
+    def register_rpc_methods(self) -> None:
+        super().register_rpc_methods()
+        self.register_rpc_method(self.set_info)
+        self.register_rpc_method(self.send_data)
+        self.register_rpc_method(self.move_abs)
+        self.register_rpc_method(self.move_rel)
+        self.register_rpc_method(self.move_home)
+        self.register_rpc_method(self.get_actuator_value)
+        self.register_rpc_method(self.stop_motion)
+
+    @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()
+
+    # 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]))
+
+    # detector commands
+    def send_data(self, grabber_type: str = "") -> None:
+        self.signals.cmd_signal.emit(ThreadCommand(f"Send Data {grabber_type}"))
+
+    # 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]))
+
+    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]))
+
+    def move_home(self) -> None:
+        self.signals.cmd_signal.emit(ThreadCommand("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"))
+
+    def stop_motion(self,) -> None:
+        # not implemented in DAQ_Move!
+        self.signals.cmd_signal.emit(ThreadCommand("stop_motion"))
+
+
+# to be able to separate them later on
+MoveActorHandler = ActorHandler
+ViewerActorHandler = ActorHandler
+
+
+class PymodaqListener(Listener):
+    """A Listener prepared for PyMoDAQ.
+
+    :param name: Name of this module.
+    :param host: Host name of the communication server.
+    :param port: Port number of the communication server.
+    """
+    remote_name: str = ""
+
+    local_methods = ["pong", "set_log_level"]
+
+    def __init__(self,
+                 name: str,
+                 handler_class: Type[PymodaqPipeHandler] = PymodaqPipeHandler,
+                 host: str = "localhost",
+                 port: int = COORDINATOR_PORT,
+                 logger: Optional[logging.Logger] = None,
+                 timeout: float = 1,
+                 **kwargs) -> None:
+        super().__init__(name, host, port, logger=logger, timeout=timeout,
+                         **kwargs)
+        self.signals = ListenerSignals()
+        # self.signals.message.connect(self.handle_message)
+        self.cmd_signal = self.signals.cmd_signal
+        self._handler_class = handler_class
+
+    def _listen(self, name: str, stop_event: Event, coordinator_host: str, coordinator_port: int,
+                data_host: str, data_port: int) -> None:
+        self.message_handler = self._handler_class(name,
+                                                   host=coordinator_host, port=coordinator_port,
+                                                   data_host=data_host, data_port=data_port,
+                                                   signals=self.signals,
+                                                   )
+        self.message_handler.register_on_name_change_method(self.indicate_sign_in_out)
+        self.message_handler.listen(stop_event=stop_event)
+
+    def stop_listen(self) -> None:
+        super().stop_listen()
+        try:
+            del self.communicator
+        except AttributeError:
+            pass
+        self.signals.cmd_signal.emit(ThreadCommand(LECOClientCommands.LECO_DISCONNECTED))
+
+    def indicate_sign_in_out(self, full_name: str):
+        if "." in full_name:
+            self.signals.cmd_signal.emit(ThreadCommand(LECOClientCommands.LECO_CONNECTED))
+        else:
+            self.signals.cmd_signal.emit(ThreadCommand(LECOClientCommands.LECO_DISCONNECTED))
+
+
+class ActorListener(PymodaqListener):
+    """Listener for modules being an Actor (being remote controlled)."""
+
+    def __init__(self,
+                 name: str,
+                 handler_class: Type[ActorHandler] = ActorHandler,
+                 host: str = "localhost",
+                 port: int = COORDINATOR_PORT,
+                 logger: Optional[logging.Logger] = None,
+                 timeout: float = 1,
+                 **kwargs) -> None:
+        super().__init__(name, handler_class=handler_class, host=host, port=port,
+                         logger=logger, timeout=timeout,
+                         **kwargs)
+
+    def start_listen(self) -> None:
+        super().start_listen()
+        self.message_handler.register_rpc_method(self.set_remote_name)
+
+    def set_remote_name(self, name: str) -> None:
+        """Define what the name of the remote for answers is."""
+        self.remote_name = name
+
+    # @Slot(ThreadCommand)
+    def queue_command(self, command: ThreadCommand) -> None:
+        """Queue a command to send it via LECO to the server."""
+
+        # generic commands
+        if command.command == LECOCommands.CONNECT:
+            try:
+                if self.thread.is_alive():
+                    return  # already started
+            except AttributeError:
+                pass  # start later on, as there is no thread.
+            self.start_listen()
+
+        elif command.command == LECOCommands.QUIT:
+            try:
+                self.stop_listen()
+            except Exception:
+                pass
+            finally:
+                self.cmd_signal.emit(ThreadCommand('disconnected'))
+
+        elif command.command == 'update_connection':
+            # self.ipaddress = command.attribute['ipaddress']
+            # self.port = command.attribute['port']
+            pass  # TODO change name?
+
+        elif command.command == LECOViewerCommands.DATA_READY:
+            # code from the original:
+            # self.data_ready(data=command.attribute)
+            # def data_ready(data): self.send_data(datas[0]['data'])
+            value = command.attribute  # type: ignore
+            self.communicator.ask_rpc(
+                receiver=self.remote_name,
+                method="set_data",
+                data=serialize_object(value),
+            )
+
+        elif command.command == 'send_info':
+            path = command.attribute['path']  # type: ignore
+            param = command.attribute['param']  # type: ignore
+            self.communicator.ask_rpc(
+                receiver=self.remote_name,
+                method="set_info",
+                path=path,
+                param_dict_str=ioxml.parameter_to_xml_string(param).decode())
+
+        elif command.command == LECOMoveCommands.POSITION:
+            value = command.attribute[0]  # type: ignore
+            self.communicator.ask_rpc(receiver=self.remote_name,
+                                      method="set_position",
+                                      position=serialize_object(value),
+                                      )
+
+        elif command.command == LECOMoveCommands.MOVE_DONE:
+            value = command.attribute[0]  # type: ignore
+            self.communicator.ask_rpc(receiver=self.remote_name,
+                                      method="set_move_done",
+                                      position=serialize_object(value),
+                                      )
+
+        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",
+                                          data=serialize_object(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",
+                                          data=serialize_object(value),
+                                          )
+            elif isinstance(value, dict):
+                self.communicator.ask_rpc(receiver=self.remote_name, method="set_y_axis", **value)
+            else:
+                raise ValueError("Nothing to send!")
+
+        else:
+            raise IOError('Unknown TCP client command')
+
+
+# to be able to separate them later on
+MoveActorListener = ActorListener
+ViewerActorListener = ActorListener

pymodaq/utils/leco/utils.py

@@ -0,0 +1,41 @@
+import subprocess
+import sys
+from typing import Any, Union, get_args
+
+# import also the DeSerializer for easier imports in dependents
+from pymodaq.utils.tcp_ip.serializer import SERIALIZABLE, Serializer, DeSerializer  # type: ignore  # noqa
+from pymodaq.utils.logger import set_logger
+
+
+logger = set_logger('leco_utils')
+
+JSON_TYPES = Union[str, int, float]
+
+
+def serialize_object(pymodaq_object: Union[SERIALIZABLE, Any]) -> Union[str, Any]:
+    """Serialize a pymodaq object, if it is not JSON compatible."""
+    if isinstance(pymodaq_object, get_args(JSON_TYPES)):
+        return pymodaq_object
+    elif isinstance(pymodaq_object, get_args(SERIALIZABLE)):
+        return Serializer(pymodaq_object).to_b64_string()
+    else:
+        raise ValueError(f"{pymodaq_object} of type '{type(pymodaq_object).__name__}' is neither "
+                         "JSON serializable, nor via PyMoDAQ.")
+
+
+def run_coordinator():
+    command = [sys.executable, '-m', 'pyleco.coordinators.coordinator']
+    subprocess.Popen(command)
+
+
+def start_coordinator():
+    from pyleco.directors.director import Director
+    try:
+        with Director(actor="COORDINATOR") as director:
+            if director.communicator.namespace is None:
+                run_coordinator()
+            else:
+                logger.info('Coordinator already running')
+    except ConnectionRefusedError as e:
+        run_coordinator()
+

pymodaq/utils/managers/action_manager.py

@@ -50,7 +50,8 @@ class QAction(QAction):
 
 def addaction(name: str = '', icon_name: str = '', tip='', checkable=False, checked=False,
               slot: Callable = None, toolbar: QtWidgets.QToolBar = None,
-              menu: QtWidgets.QMenu = None, visible=True, shortcut=None):
+              menu: QtWidgets.QMenu = None, visible=True, shortcut=None,
+              enabled=True):
     """Create a new action and add it eventually to a toolbar and a menu
 
     Parameters
@@ -73,6 +74,10 @@ def addaction(name: str = '', icon_name: str = '', tip='', checkable=False, chec
         a menu where action should be added.
     visible: bool
         display or not the action in the toolbar/menu
+    shortcut: str
+        a string defining a shortcut for this action
+    enabled: bool
+        set the enabled state
     """
     if icon_name != '':
         action = QAction(create_icon(icon_name), name, None)
@@ -92,6 +97,7 @@ def addaction(name: str = '', icon_name: str = '', tip='', checkable=False, chec
     if shortcut is not None:
         action.setShortcut(shortcut)
     action.setVisible(visible)
+    action.setEnabled(enabled)
     return action
 
 
@@ -182,9 +188,11 @@ class ActionManager:
         raise NotImplementedError(f'You have to define actions here in the following form:'
                                   f'{self.setup_actions.__doc__}')
 
-    def add_action(self, short_name: str = '', name: str = '', icon_name: str = '', tip='', checkable=False,
+    def add_action(self, short_name: str = '', name: str = '', icon_name: str = '', tip='',
+                   checkable=False,
                    checked=False, toolbar=None, menu=None,
-                   visible=True, shortcut=None, auto_toolbar=True, auto_menu=True):
+                   visible=True, shortcut=None, auto_toolbar=True, auto_menu=True,
+                   enabled=True):
         """Create a new action and add it to toolbar and menu
 
         Parameters
@@ -207,7 +215,12 @@ class ActionManager:
             a menu where action should be added. Actions can also be added later see *affect_to*
         visible: bool
             display or not the action in the toolbar/menu
-
+        auto_toolbar: bool
+            if True add this action to the defined toolbar
+        auto_menu: bool
+            if True add this action to the defined menu
+        enabled: bool
+            set the enabled state of this action
         See Also
         --------
         affect_to, pymodaq.resources.QtDesigner_Ressources.Icon_Library,
@@ -219,8 +232,9 @@ class ActionManager:
         if auto_menu:
             if menu is None:
                 menu = self._menu
-        self._actions[short_name] = addaction(name, icon_name, tip, checkable=checkable, checked=checked, toolbar=toolbar, menu=menu,
-                                              visible=visible, shortcut=shortcut)
+        self._actions[short_name] = addaction(name, icon_name, tip, checkable=checkable,
+                                              checked=checked, toolbar=toolbar, menu=menu,
+                                              visible=visible, shortcut=shortcut, enabled=enabled)
 
     def add_widget(self, short_name, klass: Union[str, QtWidgets.QWidget], *args, tip='',
                    toolbar: QtWidgets.QToolBar = None, visible=True, signal_str=None, slot: Callable=None, **kwargs):

pymodaq/utils/managers/parameter_manager.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import List, Union, Dict
+from typing import List, Union, Dict, Optional
 
 from qtpy import QtWidgets, QtCore
 from pymodaq.utils.managers.action_manager import ActionManager
@@ -84,7 +84,9 @@ class ParameterManager:
     settings_name = 'custom_settings'
     params = []
 
-    def __init__(self, settings_name: str = None, action_list: tuple = ('save', 'update', 'load')):
+    def __init__(self, settings_name: Optional[str] = None,
+                 action_list: tuple = ('save', 'update', 'load'),
+                 ):
         if settings_name is None:
             settings_name = self.settings_name
         # create a settings tree to be shown eventually in a dock
@@ -96,7 +98,7 @@ class ParameterManager:
         self._settings_tree.get_action(f'update_settings').connect_to(self.update_settings_slot)
         self._settings_tree.get_action(f'load_settings').connect_to(self.load_settings_slot)
                                                                         
-        self.settings: Parameter = Parameter.create(name=settings_name, type='group', children=self.params)  # create a Parameter
+        self.settings = Parameter.create(name=settings_name, type='group', children=self.params)  # create a Parameter
         # object containing the settings defined in the preamble
 
     @property
@@ -108,7 +110,7 @@ class ParameterManager:
         return self._settings_tree.tree
 
     @property
-    def settings(self):
+    def settings(self) -> Parameter:
         return self._settings
 
     @settings.setter