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

pymodaq/utils/h5modules/module_saving.py

@@ -6,19 +6,21 @@ Created the 23/11/2022
 """
 from __future__ import annotations
 
-from typing import Union, List, Dict, Tuple, TYPE_CHECKING
+from typing import Union, List, Dict, Tuple, TYPE_CHECKING, Iterable
 import xml.etree.ElementTree as ET
 
 
 import numpy as np
 from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils.enums import BaseEnum
 from pymodaq_utils.abstract import ABCMeta, abstract_attribute, abstractmethod
 from pymodaq_utils.utils import capitalize
 from pymodaq_data.data import Axis, DataDim, DataWithAxes, DataToExport, DataDistribution
 from pymodaq_data.h5modules.saving import H5SaverLowLevel
 from pymodaq_data.h5modules.backends import GROUP, CARRAY, Node, GroupType
-from pymodaq_data.h5modules.data_saving import (DataToExportSaver, AxisSaverLoader,
-                                                DataToExportTimedSaver, DataToExportExtendedSaver)
+from pymodaq_data.h5modules.data_saving import (
+    DataToExportSaver, AxisSaverLoader, DataToExportEnlargeableSaver,
+    DataToExportTimedSaver, DataToExportExtendedSaver)
 from pymodaq_gui.parameter import ioxml
 
 if TYPE_CHECKING:
@@ -31,9 +33,17 @@ if TYPE_CHECKING:
 logger = set_logger(get_module_name(__file__))
 
 
+class GroupModuleType(BaseEnum):
+    DETECTOR = 0
+    ACTUATOR = 1
+    SCAN = 2
+    DATALOGGER = 3
+    OPTIMIZER = 4
+
+
 class ModuleSaver(metaclass=ABCMeta):
     """Abstract base class to save info and data from main modules (DAQScan, DAQViewer, DAQMove, ...)"""
-    group_type: GroupType = abstract_attribute()
+    group_type: GroupModuleType = abstract_attribute()
     _module = abstract_attribute()
     _h5saver: H5SaverLowLevel = abstract_attribute()
     _module_group: GROUP = abstract_attribute()
@@ -119,11 +129,11 @@ class ModuleSaver(metaclass=ABCMeta):
 
     def get_last_node_index(self, where: Union[Node, str] = None):
         node = self.get_last_node(where)
-        return int(node.name.split(capitalize(self.group_type.name))[1])
+        return int(node.name.split(capitalize(self.group_type.name.lower()))[1])
 
     def get_next_node_name(self, where: Union[Node, str] = None):
         index = self.get_last_node_index(where)
-        return f'{capitalize(self.group_type.name)}{index+1:03d}'
+        return f'{capitalize(self.group_type.name.lower())}{index+1:03d}'
 
 
 class DetectorSaver(ModuleSaver):
@@ -133,7 +143,7 @@ class DetectorSaver(ModuleSaver):
     ----------
     module
     """
-    group_type = GroupType['detector']
+    group_type = GroupModuleType.DETECTOR
 
     def __init__(self, module: DAQ_Viewer):
         self._datatoexport_saver: DataToExportSaver = None
@@ -176,8 +186,8 @@ class DetectorSaver(ModuleSaver):
         return self._h5saver.add_det_group(where, title=self._module.title, settings_as_xml=ET.tostring(settings_xml),
                                            metadata=metadata)
 
-    def add_data(self, where: Union[Node, str], data: DataToExport):
-        self._datatoexport_saver.add_data(where, data)
+    def add_data(self, where: Union[Node, str], data: DataToExport, **kwargs):
+        self._datatoexport_saver.add_data(where, data, **kwargs)
 
     def add_bkg(self, where: Union[Node, str], data_bkg: DataToExport):
         """ Adds a DataToExport as a background node in the h5file
@@ -213,14 +223,14 @@ class DetectorSaver(ModuleSaver):
                 self.logger.exception(str(e))
 
 
-class DetectorEnlargeableSaver(DetectorSaver):
+class DetectorTimeSaver(DetectorSaver):
     """Implementation of the ModuleSaver class dedicated to DAQ_Viewer modules in order to save enlargeable data
 
     Parameters
     ----------
     module
     """
-    group_type = GroupType['detector']
+    group_type = GroupModuleType.DETECTOR
 
     def __init__(self, module: DAQ_Viewer):
         super().__init__(module)
@@ -230,6 +240,28 @@ class DetectorEnlargeableSaver(DetectorSaver):
         self._datatoexport_saver = DataToExportTimedSaver(self.h5saver)
 
 
+class DetectorEnlargeableSaver(DetectorSaver):
+    """Implementation of the ModuleSaver class dedicated to DAQ_Viewer modules in order to save enlargeable data
+
+    Parameters
+    ----------
+    module
+    """
+    group_type = GroupModuleType.DETECTOR
+
+    def __init__(self, module: DAQ_Viewer,
+                 enl_axis_names: Iterable[str] = None,
+                 enl_axis_units: Iterable[str] = None,):
+        super().__init__(module)
+        self.enl_axis_names = enl_axis_names
+        self.enl_axis_units = enl_axis_units
+        self._datatoexport_saver: DataToExportEnlargeableSaver = None
+
+    def update_after_h5changed(self):
+        self._datatoexport_saver = DataToExportEnlargeableSaver(
+            self.h5saver, self.enl_axis_names, self.enl_axis_units)
+
+
 class DetectorExtendedSaver(DetectorSaver):
     """Implementation of the ModuleSaver class dedicated to DAQ_Viewer modules in order to save enlargeable data
 
@@ -237,7 +269,7 @@ class DetectorExtendedSaver(DetectorSaver):
     ----------
     module
     """
-    group_type = GroupType['detector']
+    group_type = GroupModuleType.DETECTOR
 
     def __init__(self, module: DAQ_Viewer, extended_shape: Tuple[int]):
         super().__init__(module)
@@ -263,18 +295,20 @@ class ActuatorSaver(ModuleSaver):
     h5saver
     module
     """
-    group_type = GroupType['actuator']
+    group_type = GroupModuleType.ACTUATOR
 
     def __init__(self, module: DAQ_Move):
-        self._datatoexport_saver: DataToExportTimedSaver = None
+        self._datatoexport_saver: DataToExportSaver = None
         self._module_group: GROUP = None
         self._module: DAQ_Move = module
         self._h5saver = None
 
     def update_after_h5changed(self, ):
-        self._datatoexport_saver = DataToExportTimedSaver(self.h5saver)
+        self._datatoexport_saver = DataToExportSaver(self.h5saver)
 
-    def _add_module(self, where: Union[Node, str] = None, metadata={}):
+    def _add_module(self, where: Union[Node, str] = None, metadata=None):
+        if metadata is None:
+            metadata={}
         if where is None:
             where = self._h5saver.raw_group
 
@@ -288,6 +322,46 @@ class ActuatorSaver(ModuleSaver):
         self._datatoexport_saver.add_data(where, data)
 
 
+class ActuatorTimeSaver(ActuatorSaver):
+    def __init__(self, module: DAQ_Move):
+        super().__init__(module)
+        self._datatoexport_saver: DataToExportTimedSaver = None
+
+    def update_after_h5changed(self, ):
+        self._datatoexport_saver = DataToExportTimedSaver(self.h5saver)
+
+    def add_data(self, where: Union[Node, str], data: DataToExport):
+        self._datatoexport_saver.add_data(where, data)
+
+
+class ActuatorEnlargeableSaver(ActuatorTimeSaver):
+    """Implementation of the ModuleSaver class dedicated to DAQ_Move modules
+
+    Parameters
+    ----------
+    h5saver
+    module
+    """
+
+    def __init__(self, module: DAQ_Move,
+                 enl_axis_names: Iterable[str] = None,
+                 enl_axis_units: Iterable[str] = None,):
+        super().__init__(module)
+        self.enl_axis_names = enl_axis_names
+        self.enl_axis_units = enl_axis_units
+        self._datatoexport_saver: DataToExportEnlargeableSaver = None
+
+    def update_after_h5changed(self, ):
+        self._datatoexport_saver = DataToExportEnlargeableSaver(
+            self.h5saver, self.enl_axis_names, self.enl_axis_units)
+
+
+    def add_data(self, where: Union[Node, str], data: DataToExport,
+                 axis_values: List[Union[float, np.ndarray]] = None,
+                 **kwargs):
+        self._datatoexport_saver.add_data(where, data, axis_values, **kwargs)
+
+
 class ScanSaver(ModuleSaver):
     """Implementation of the ModuleSaver class dedicated to DAQScan module
 
@@ -296,7 +370,7 @@ class ScanSaver(ModuleSaver):
     h5saver
     module
     """
-    group_type = GroupType['scan']
+    group_type = GroupModuleType.SCAN
 
     def __init__(self, module):
         self._module_group: GROUP = None
@@ -341,7 +415,7 @@ class ScanSaver(ModuleSaver):
             module.module_and_data_saver.get_set_node(self._module_group)
         return self._module_group
 
-    def _add_module(self, where: Union[Node, str] = None, metadata={}) -> Node:
+    def _add_module(self, where: Union[Node, str] = None, metadata=None) -> Node:
         """
 
         Parameters
@@ -354,6 +428,8 @@ class ScanSaver(ModuleSaver):
         -------
 
         """
+        if metadata is None:
+            metadata = {}
         if where is None:
             where = self._h5saver.raw_group
 
@@ -363,16 +439,17 @@ class ScanSaver(ModuleSaver):
             saver_xml = ET.SubElement(settings_xml, 'H5Saver', type='group')
             saver_xml.append(ioxml.walk_parameters_to_xml(param=self._h5saver.settings))
 
-        return self._h5saver.add_scan_group(where, title=self._module.title,
+        return self._h5saver.add_generic_group(where, title=self._module.title,
                                             settings_as_xml=ET.tostring(settings_xml),
-                                            metadata=metadata)
+                                            metadata=metadata,
+                                            group_type=self.group_type.name)
 
     def add_nav_axes(self, axes: List[Axis]):
         for detector in self._module.modules_manager.detectors:
             detector.module_and_data_saver.add_nav_axes(self._module_group, axes)
 
     def add_data(self, dte: DataToExport = None, indexes: Tuple[int] = None,
-                 distribution=DataDistribution['uniform']):
+                 distribution=DataDistribution['uniform'], **kwargs):
         for detector in self._module.modules_manager.detectors:
             try:
                 detector.insert_data(indexes, where=self._module_group, distribution=distribution)
@@ -390,7 +467,7 @@ class LoggerSaver(ScanSaver):
     h5saver
     module
     """
-    group_type = GroupType['data_logger']
+    group_type = GroupModuleType.DATALOGGER
 
     def add_data(self, dte: DataToExport):
         """Add data to it's corresponding control module
@@ -407,3 +484,38 @@ class LoggerSaver(ScanSaver):
             return
 
         control_module.append_data(dte=dte, where=self._module_group)
+
+
+class OptimizerSaver(ScanSaver):
+    """Implementation of the ModuleSaver class dedicated to Optimizer based modules
+
+    Parameters
+    ----------
+    h5saver
+    module
+    """
+    group_type = GroupModuleType.OPTIMIZER
+
+    def __init__(self, module,
+                 enl_axis_names: Iterable[str] = None,
+                 enl_axis_units: Iterable[str] = None,):
+        super().__init__(module)
+        self.enl_axis_names = enl_axis_names
+        self.enl_axis_units = enl_axis_units
+
+    def update_after_h5changed(self, ):
+        for module in self._module.modules_manager.detectors:
+            module.module_and_data_saver = DetectorEnlargeableSaver(
+                module, self.enl_axis_names, self.enl_axis_units)
+            module.module_and_data_saver.h5saver = self.h5saver
+
+
+    def add_data(self, *args, axis_values: List[Union[float, np.ndarray]] = None,
+                 **kwargs):
+        for module in self._module.modules_manager.detectors:
+            try:
+                module.append_data(where=self._module_group,
+                                   axis_values=axis_values,
+                                   **kwargs)
+            except Exception as e:
+                logger.exception(f'Cannot append data: {str(e)}')

pymodaq/utils/leco/daq_move_LECODirector.py

@@ -7,17 +7,27 @@ running: `python -m pyleco.coordinators.coordinator`
 
 """
 
-from typing import Union
+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
+from pymodaq.utils.leco.leco_director import (LECODirector, leco_parameters, DirectorCommands,
+                                              DirectorReceivedCommands)
 from pymodaq.utils.leco.director_utils import ActuatorDirector
-from pymodaq_utils.serialize.serializer_legacy import DeSerializer
+
+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.
@@ -35,38 +45,44 @@ class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
         utility_classes.DAQ_TCP_server
     """
     settings: Parameter
-    controller: ActuatorDirector
+    controller: Optional[ActuatorDirector]
+    _axis_names = ['']
+    _controller_units = ['']
+    _epsilon = 1
 
     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() + leco_parameters
-
-    def __init__(self, parent=None, params_state=None, **kwargs) -> None:
-        super().__init__(parent=parent,
-                         params_state=params_state, **kwargs)
+    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_info,
+            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
         ))
-        for method in (
-            self.set_position,
-            self.set_move_done,
-            self.set_x_axis,
-            self.set_y_axis,
-        ):
-            self.listener.register_binary_rpc_method(method, accept_binary_input=True)
-
-        # 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)
+        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
@@ -83,96 +99,119 @@ class DAQ_Move_LECODirector(LECODirector, DAQ_Move_base):
         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
+        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.controller.move_abs(position=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 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
+        """ Get the current hardware value """
         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, None], additional_payload=None
+        self, data: Union[dict, list, str, float, None], additional_payload=None
     ) -> DataActuator:
-        if position:
-            if isinstance(position, str):
-                deserializer = DeSerializer.from_b64_string(position)
-                pos = deserializer.dwa_deserialization()
-            else:
-                pos = DataActuator(data=position)
-        elif additional_payload is not None:
-            pos = DeSerializer(additional_payload[0]).dwa_deserialization()
+
+        # 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 set_position(self, position: Union[str, float, None], additional_payload=None) -> None:
-        pos = self._set_position_value(position=position, additional_payload=additional_payload)
-        self.emit_status(ThreadCommand('get_actuator_value', [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_move_done(self, position: Union[str, float, None], additional_payload=None) -> None:
-        pos = self._set_position_value(position=position, additional_payload=additional_payload)
-        self.emit_status(ThreadCommand('move_done', [pos]))
+    def set_director_settings(self, settings: bytes):
+        """ Get the content of the actor settings to pe populated in this plugin
+        'settings_client' parameter
 
-    def set_x_axis(self, data, label: str = "", units: str = "") -> None:
-        raise NotImplementedError("where is it handled?")
+        Then set the plugin units from this information"""
+        super().set_director_settings(settings)
+        self.axis_unit = self.settings['settings_client', 'units']
 
-    def set_y_axis(self, data, label: str = "", units: str = "") -> None:
-        raise NotImplementedError("where is it handled?")
+    def close(self) -> None:
+        """ Clear the content of the settings_clients setting"""
+        super().close()
 
 
 if __name__ == '__main__':
-    main(__file__)
+    main(__file__, init=False)