pymodaq 4.1.0__tar.gz → 4.1.1__tar.gz

{pymodaq-4.1.0 → pymodaq-4.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pymodaq
-Version: 4.1.0
+Version: 4.1.1
 Summary: Modular Data Acquisition with Python
 Project-URL: Homepage, http://pymodaq.cnrs.fr
 Project-URL: Source, https://github.com/PyMoDAQ/PyMoDAQ

{pymodaq-4.1.0 → pymodaq-4.1.1}/src/pymodaq/control_modules/daq_move.py

@@ -172,7 +172,7 @@ class DAQ_Move(ParameterManager, ControlModule):
         elif cmd.command == 'rel_value':
             self._relative_value = cmd.attribute
 
-    def append_data(self, data: DataToExport = None, where: Union[Node, str] = None):
+    def append_data(self, dte: DataToExport = None, where: Union[Node, str] = None):
         """Appends current DataToExport to an ActuatorEnlargeableSaver
 
         Parameters
@@ -183,9 +183,9 @@ class DAQ_Move(ParameterManager, ControlModule):
         --------
         ActuatorEnlargeableSaver
         """
-        if data is None:
-            data = DataToExport(name=self.title, data=[self._current_value])
-        self._add_data_to_saver(data, where=where)
+        if dte is None:
+            dte = DataToExport(name=self.title, data=[self._current_value])
+        self._add_data_to_saver(dte, where=where)
         # todo: test this for logging
 
     def _add_data_to_saver(self, data: DataToExport, where=None, **kwargs):

{pymodaq-4.1.0 → pymodaq-4.1.1}/src/pymodaq/extensions/daq_scan.py

@@ -70,7 +70,8 @@ class DAQScan(QObject, ParameterManager):
     live_data_1D_signal = Signal(list)
 
     params = [
-        {'title': 'Time Flow:', 'name': 'time_flow', 'type': 'group', 'expanded': False, 'children': [
+        {'title': 'Time Flow:', 'name': 'time_flow', 'type': 'group', 'expanded': False,
+         'children': [
             {'title': 'Wait time step (ms)', 'name': 'wait_time', 'type': 'int', 'value': 0,
              'tip': 'Wait time in ms after each step of acquisition (move and grab)'},
             {'title': 'Wait time between (ms)', 'name': 'wait_time_between', 'type': 'int',
@@ -85,11 +86,13 @@ class DAQScan(QObject, ParameterManager):
         {'title': 'Plotting options', 'name': 'plot_options', 'type': 'group', 'children': [
             {'title': 'Get data', 'name': 'plot_probe', 'type': 'bool_push'},
             {'title': 'Group 0D data:', 'name': 'group0D', 'type': 'bool', 'value': True},
-            {'title': 'Plot 0Ds:', 'name': 'plot_0d', 'type': 'itemselect'},
-            {'title': 'Plot 1Ds:', 'name': 'plot_1d', 'type': 'itemselect'},
+            {'title': 'Plot 0Ds:', 'name': 'plot_0d', 'type': 'itemselect', 'checkbox': True},
+            {'title': 'Plot 1Ds:', 'name': 'plot_1d', 'type': 'itemselect', 'checkbox': True},
             {'title': 'Prepare Viewers', 'name': 'prepare_viewers', 'type': 'bool_push'},
-            {'title': 'Plot at each step?', 'name': 'plot_at_each_step', 'type': 'bool', 'value': True},
-            {'title': 'Refresh Plots (ms)', 'name': 'refresh_live', 'type': 'int', 'value': 1000, 'visible': False},
+            {'title': 'Plot at each step?', 'name': 'plot_at_each_step', 'type': 'bool',
+             'value': True},
+            {'title': 'Refresh Plots (ms)', 'name': 'refresh_live', 'type': 'int',
+             'value': 1000, 'visible': False},
             ]},
     ]
 
@@ -679,6 +682,14 @@ class DAQScan(QObject, ParameterManager):
     def save_temp_live_data(self, scan_data: ScanDataTemp):
         if scan_data.scan_index == 0:
             nav_axes = self.scanner.get_nav_axes()
+            Naverage = self.settings['scan_options', 'scan_average']
+            if Naverage > 1:
+                for nav_axis in nav_axes:
+                    nav_axis.index += 1
+                nav_axes.append(data_mod.Axis('Average',
+                                              data=np.linspace(0, Naverage - 1, Naverage),
+                                              index=0))
+
             self.extended_saver.add_nav_axes(self.h5temp.raw_group, nav_axes)
 
         self.extended_saver.add_data(self.h5temp.raw_group, scan_data.data, scan_data.indexes,
@@ -694,8 +705,14 @@ class DAQScan(QObject, ParameterManager):
             average_axis = None
         try:
             self.live_plotter.load_plot_data(group_0D=self.settings['plot_options', 'group0D'],
-                                             average_axis=average_axis, average_index=self.ind_average,
-                                             target_at=self.scanner.positions[self.ind_scan])
+                                             average_axis=average_axis,
+                                             average_index=self.ind_average,
+                                             target_at=self.scanner.positions[self.ind_scan],
+                                             last_step=(self.ind_scan ==
+                                                        self.scanner.positions.size - 1 and
+                                                        self.ind_average ==
+                                                        self.settings[
+                                                            'scan_options', 'scan_average'] - 1))
         except Exception as e:
             logger.exception(str(e))
     #################
@@ -1100,7 +1117,8 @@ class DAQScanAcquisition(QObject):
                 if self.Naverage > 1:
                     for nav_axis in nav_axes:
                         nav_axis.index += 1
-                    nav_axes.append(data_mod.Axis('Average', data=np.linspace(0, self.Naverage - 1, self.Naverage),
+                    nav_axes.append(data_mod.Axis('Average', data=np.linspace(0, self.Naverage - 1,
+                                                                              self.Naverage),
                                                   index=0))
                 self.module_and_data_saver.add_nav_axes(nav_axes)
 

{pymodaq-4.1.0 → pymodaq-4.1.1}/src/pymodaq/post_treatment/load_and_plot.py

@@ -59,9 +59,12 @@ class LoaderPlotter:
     def data(self) -> DataToExport:
         return self._data
 
-    def load_data(self, filter_dims: List[Union[DataDim, str]] = None, filter_full_names: List[str] = None,
-                  remove_navigation: bool = True, group_0D=False, average_axis: int=None, average_index: int = 0):
-        """Load Data from the h5 node of the dataloader and apply some filtering/manipulation before plotting
+    def load_data(self, filter_dims: List[Union[DataDim, str]] = None,
+                  filter_full_names: List[str] = None, remove_navigation: bool = True,
+                  group_0D=False, average_axis: int=None, average_index: int = 0,
+                  last_step=False):
+        """Load Data from the h5 node of the dataloader and apply some filtering/manipulation before
+        plotting
 
         Parameters
         ----------
@@ -70,14 +73,17 @@ class LoaderPlotter:
         filter_full_names: List[str]
             load only data matching these names
         remove_navigation: bool
-            if True, make navigation axes as signal axes (means DataND could be plotted on Viewer1D or
-            Viewer2D by concatenation)
+            if True, make navigation axes as signal axes (means DataND could be plotted on Viewer1D
+            or Viewer2D by concatenation)
         group_0D: bool
             if True, group all (initial) Data0D into one DataFromPlugins
         average_axis: int or None
-            which axis in the data shapes should be interpereted as the average (in general it is 0 or None)
+            which axis in the data shapes should be interpereted as the average (in general it is 0
+            or None)
         average_index: int
             which step in the averaging process are we in.
+        last_step: bool
+            tells if this is the very last step of the (averaged) scan
 
         Returns
         -------
@@ -88,14 +94,15 @@ class LoaderPlotter:
         self.dataloader.load_all('/', self._data)
 
         if average_axis is not None:
-            self.average_axis(average_axis, average_index)
+            self.average_axis(average_axis, average_index, last_step=last_step)
 
         if filter_dims is not None:
             filter_dims[:] = [enum_checker(DataDim, dim) for dim in filter_dims]
             self._data.data[:] = [data for data in self._data if data.dim in filter_dims]
 
         if filter_full_names is not None:
-            self._data.data[:] = [data for data in self._data if data.get_full_name() in filter_full_names]
+            self._data.data[:] = [data for data in self._data if data.get_full_name() in
+                                  filter_full_names]
 
         if group_0D:  # 0D initial data
             self.group_0D_data()
@@ -105,31 +112,39 @@ class LoaderPlotter:
 
         return self._data
 
-    def average_axis(self, average_axis, average_index) -> None:
+    def average_axis(self, average_axis, average_index, last_step=False) -> None:
         """ Average the data along their average axis
 
         Parameters
         ----------
         average_axis: int or None
-            which axis in the data shapes should be interpereted as the average (in general it is 0 or None)
+            which axis in the data shapes should be interpreted as the average
+            (in general it is 0 or None)
         average_index: int
             which step in the averaging process are we in.
+        last_step: bool
+            tells if this is the very last step of the (averaged) scan
         """
         for ind, data in enumerate(self._data):
             current_data = data.inav[average_index, ...]
-            if average_index == 0:
-                data_to_append = data.inav[0:average_index + 1, ...]
-            else:
-                data_to_append = data.inav[0:average_index + 1, ...].mean(axis=average_axis)
-            data_to_append.labels = [f'{label}_averaged' for label in data_to_append.labels]
-            current_data.append(data_to_append)
+            if average_index > 0:
+                if last_step:
+                    data_to_append = data.inav[0:, ...].mean(axis=average_axis)
+                else:
+                    if average_index == 1:
+                        data_to_append = data.inav[0, ...]
+                    else:
+                        data_to_append = data.inav[0:average_index, ...].mean(axis=average_axis)
+
+                data_to_append.labels = [f'{label}_averaged' for label in data_to_append.labels]
+                current_data.append(data_to_append)
             self._data[ind] = current_data
 
     def remove_navigation_axes(self):
         """Make the navigation axes as signal axes
 
-        transforms DataND into Data1D or Data2D or error... depending the exact shape of the data and the number of
-        navigation axes
+        transforms DataND into Data1D or Data2D or error... depending the exact shape of the data
+        and the number of navigation axes
         """
         for data in self._data:
             data.nav_indexes = ()
@@ -164,10 +179,17 @@ class LoaderPlotter:
         -----
         load_data
         """
-        if 'target_at' in kwargs:
-            target_at = kwargs.pop('target_at')
+
+        target_at = kwargs.pop('target_at') if 'target_at' in kwargs else None
+        last_step = kwargs.pop('last_step') if 'last_step' in kwargs else False
+
         self.load_data(**kwargs)
         self.show_data(target_at=target_at)
+        if (last_step and 'average_index' in kwargs and kwargs['average_index']
+                is not None):
+            kwargs['last_step'] = last_step
+            self.load_data(**kwargs)
+            self.show_data(target_at=target_at)
 
     def show_data(self, **kwargs):
         """Send data to their dedicated viewers
@@ -197,7 +219,8 @@ class LoaderPlotter:
         self._viewers = dict(zip(viewers_name, self.dispatcher.viewers))
         self._viewer_docks = dict(zip(viewers_name, self.dispatcher.viewer_docks))
 
-    def set_data_to_viewers(self, data: DataToExport, temp=False, target_at: Iterable[float] = None):
+    def set_data_to_viewers(self, data: DataToExport, temp=False,
+                            target_at: Iterable[float] = None):
         """Process data dimensionality and send appropriate data to their data viewers
 
         Parameters

pymodaq-4.1.1/src/pymodaq/resources/VERSION

@@ -0,0 +1 @@
+version = '4.1.1'

{pymodaq-4.1.0 → pymodaq-4.1.1}/src/pymodaq/utils/data.py

@@ -1588,6 +1588,13 @@ class DataWithAxes(DataBase):
         """convenience property to set attribute from axis_manager"""
         self.set_axes_manager(self.shape, axes=axes, nav_indexes=self.nav_indexes)
 
+    def axes_limits(self, axes_indexes: List[int] = None) -> List[Tuple[float, float]]:
+        """Get the limits of specified axes (all if axes_indexes is None)"""
+        if axes_indexes is None:
+            return [(axis.min(), axis.max()) for axis in self.axes]
+        else:
+            return [(axis.min(), axis.max()) for axis in self.axes if axis.index in axes_indexes]
+
     @property
     def sig_indexes(self):
         """convenience property to fetch attribute from axis_manager"""

{pymodaq-4.1.0 → pymodaq-4.1.1}/src/pymodaq/utils/h5modules/data_saving.py

@@ -5,7 +5,7 @@ Created the 21/11/2022
 @author: Sebastien Weber
 """
 from time import time
-from typing import Union, List, Tuple
+from typing import Union, List, Tuple, Iterable
 
 import numpy as np
 
@@ -308,7 +308,8 @@ class DataSaverLoader(DataManagement):
                 bkg_nodes.append(node)
         return bkg_nodes
 
-    def get_data_arrays(self, where: Union[Node, str], with_bkg=False, load_all=False) -> List[np.ndarray]:
+    def get_data_arrays(self, where: Union[Node, str], with_bkg=False,
+                        load_all=False) -> List[np.ndarray]:
         """
 
         Parameters
@@ -338,15 +339,17 @@ class DataSaverLoader(DataManagement):
             getter = self._get_nodes
 
         if with_bkg:
-            return [np.atleast_1d(np.squeeze(array.read()-bkg.read())) for array, bkg in zip(getter(where), bkg_nodes)]
+            return [np.atleast_1d(np.squeeze(array.read()-bkg.read()))
+                    for array, bkg in zip(getter(where), bkg_nodes)]
         else:
             return [np.atleast_1d(np.squeeze(array.read())) for array in getter(where)]
 
     def load_data(self, where, with_bkg=False, load_all=False) -> DataWithAxes:
-        """Return a DataWithAxes object from the Data and Axis Nodes hanging from (or among) a given Node
+        """Return a DataWithAxes object from the Data and Axis Nodes hanging from (or among) a
+        given Node
 
-        Does not include navigation axes stored elsewhere in the h5file. The node path is stored in the DatWithAxis
-        using the attribute path
+        Does not include navigation axes stored elsewhere in the h5file. The node path is stored in
+        the DatWithAxis using the attribute path
 
         Parameters
         ----------
@@ -383,18 +386,21 @@ class DataSaverLoader(DataManagement):
             axes = self.get_axes(parent_node)
 
         extra_attributes = data_node.attrs.to_dict()
-        for name in ['TITLE', 'CLASS', 'VERSION', 'backend', 'source', 'data_dimension', 'distribution', 'label',
-                     'origin', 'nav_indexes', 'dtype', 'data_type', 'subdtype', 'shape', 'size', 'EXTDIM', 'path']:
+        for name in ['TITLE', 'CLASS', 'VERSION', 'backend', 'source', 'data_dimension',
+                     'distribution', 'label', 'origin', 'nav_indexes', 'dtype', 'data_type',
+                     'subdtype', 'shape', 'size', 'EXTDIM', 'path']:
             extra_attributes.pop(name, None)
 
         data = DataWithAxes(data_node.attrs['TITLE'],
-                            source=data_node.attrs['source'] if 'source' in data_node.attrs else 'raw',
+                            source=data_node.attrs['source'] if 'source' in data_node.attrs
+                            else 'raw',
                             dim=data_node.attrs['data_dimension'],
                             distribution=data_node.attrs['distribution'],
                             data=ndarrays,
                             labels=[node.attrs['label'] for node in data_nodes],
                             origin=data_node.attrs['origin'] if 'origin' in data_node.attrs else '',
-                            nav_indexes=data_node.attrs['nav_indexes'] if 'nav_indexes' in data_node.attrs else (),
+                            nav_indexes=data_node.attrs['nav_indexes'] if 'nav_indexes' in
+                                                                          data_node.attrs else (),
                             axes=axes,
                             path=data_node.path,
                             **extra_attributes)
@@ -575,7 +581,7 @@ class DataExtendedSaver(DataSaverLoader):
         where: Union[Node, str]
             the path of a given node or the node itself
         data: DataWithAxes
-        indexes: List[int]
+        indexes: Iterable[int]
             indexes where to save data in the init h5array (should have the same length as extended_shape and with values
             coherent with this shape
         """
@@ -591,7 +597,8 @@ class DataExtendedSaver(DataSaverLoader):
         for ind_data in range(len(data)):
             #todo check that getting with index is safe...
             array: CARRAY = self.get_node_from_index(where, ind_data)
-            array[tuple(indexes)] = data[ind_data]  # maybe use array.__setitem__(indexes, data[ind_data]) if it's not working
+            array[tuple(indexes)] = data[ind_data]
+            # maybe use array.__setitem__(indexes, data[ind_data]) if it's not working
 
 
 class DataToExportSaver:
@@ -619,11 +626,12 @@ class DataToExportSaver:
 
     @staticmethod
     def channel_formatter(ind: int):
-        """All DataWithAxes included in the DataToExport will be saved into a channel group indexed and
-        formatted as below"""
+        """All DataWithAxes included in the DataToExport will be saved into a channel group indexed
+        and formatted as below"""
         return f'CH{ind:02d}'
 
-    def add_data(self, where: Union[Node, str], data: DataToExport, settings_as_xml='', metadata=None):
+    def add_data(self, where: Union[Node, str], data: DataToExport, settings_as_xml='',
+                 metadata=None):
         """
 
         Parameters
@@ -642,8 +650,10 @@ class DataToExportSaver:
         dims = data.get_dim_presents()
         for dim in dims:
             dim_group = self._h5saver.get_set_group(where, dim)
-            for ind, dwa in enumerate(data.get_data_from_dim(dim)):  # dwa: DataWithAxes filtered by dim
-                dwa_group = self._h5saver.get_set_group(dim_group, self.channel_formatter(ind), dwa.name)
+            for ind, dwa in enumerate(data.get_data_from_dim(dim)):
+                # dwa: DataWithAxes filtered by dim
+                dwa_group = self._h5saver.get_set_group(dim_group, self.channel_formatter(ind),
+                                                        dwa.name)
                 # dwa_group = self._h5saver.add_ch_group(dim_group, dwa.name)
                 self._data_saver.add_data(dwa_group, dwa)
 
@@ -651,8 +661,10 @@ class DataToExportSaver:
         dims = data.get_dim_presents()
         for dim in dims:
             dim_group = self._h5saver.get_set_group(where, dim)
-            for ind, dwa in enumerate(data.get_data_from_dim(dim)):  # dwa: DataWithAxes filtered by dim
-                dwa_group = self._h5saver.get_set_group(dim_group, self.channel_formatter(ind), dwa.name)
+            for ind, dwa in enumerate(data.get_data_from_dim(dim)):
+                # dwa: DataWithAxes filtered by dim
+                dwa_group = self._h5saver.get_set_group(dim_group,
+                                                        self.channel_formatter(ind), dwa.name)
                 # dwa_group = self._get_node_from_title(dim_group, dwa.name)
                 if dwa_group is not None:
                     self._bkg_saver.add_data(dwa_group, dwa, save_axes=False)
@@ -679,8 +691,8 @@ class DataToExportEnlargeableSaver(DataToExportSaver):
         self._axis_name = axis_name
         self._axis_units = axis_units
 
-    def add_data(self, where: Union[Node, str], data: DataToExport, axis_value: Union[float, np.ndarray],
-                 settings_as_xml='', metadata=None):
+    def add_data(self, where: Union[Node, str], data: DataToExport,
+                 axis_value: Union[float, np.ndarray], settings_as_xml='', metadata=None):
         """
 
         Parameters
@@ -712,7 +724,8 @@ class DataToExportEnlargeableSaver(DataToExportSaver):
 class DataToExportTimedSaver(DataToExportEnlargeableSaver):
     """Specialized DataToExportEnlargeableSaver to save data as a function of a time axis
 
-    Only one element ca be added at a time, the time axis value are enlarged using the data to be added timestamp
+    Only one element ca be added at a time, the time axis value are enlarged using the data to be
+    added timestamp
 
     Notes
     -----
@@ -721,8 +734,10 @@ class DataToExportTimedSaver(DataToExportEnlargeableSaver):
     def __init__(self, h5saver: H5Saver):
         super().__init__(h5saver, 'time', 's')
 
-    def add_data(self, where: Union[Node, str], data: DataToExport, settings_as_xml='', metadata=None):
-        super().add_data(where, data, axis_value=data.timestamp, settings_as_xml=settings_as_xml, metadata=metadata)
+    def add_data(self, where: Union[Node, str], data: DataToExport, settings_as_xml='',
+                 metadata=None):
+        super().add_data(where, data, axis_value=data.timestamp, settings_as_xml=settings_as_xml,
+                         metadata=metadata)
 
 
 class DataToExportExtendedSaver(DataToExportSaver):
@@ -755,7 +770,7 @@ class DataToExportExtendedSaver(DataToExportSaver):
             for axis in axes:
                 self._nav_axis_saver.add_axis(nav_group, axis)
 
-    def add_data(self, where: Union[Node, str], data: DataToExport, indexes: List[int],
+    def add_data(self, where: Union[Node, str], data: DataToExport, indexes: Iterable[int],
                  distribution=DataDistribution['uniform'],
                  settings_as_xml='', metadata={}):
         """
@@ -766,8 +781,8 @@ class DataToExportExtendedSaver(DataToExportSaver):
             the path of a given node or the node itself
         data: DataToExport
         indexes: List[int]
-            indexes where to save data in the init h5array (should have the same length as extended_shape and with values
-            coherent with this shape
+            indexes where to save data in the init h5array (should have the same length as
+            extended_shape and with values coherent with this shape
         settings_as_xml: str
             The settings parameter as an XML string
         metadata: dict
@@ -777,9 +792,12 @@ class DataToExportExtendedSaver(DataToExportSaver):
         dims = data.get_dim_presents()
         for dim in dims:
             dim_group = self._h5saver.get_set_group(where, dim)
-            for ind, dwa in enumerate(data.get_data_from_dim(dim)):  # dwa: DataWithAxes filtered by dim
-                dwa_group = self._h5saver.get_set_group(dim_group, self.channel_formatter(ind), dwa.name)
-                self._data_saver.add_data(dwa_group, dwa, indexes=indexes, distribution=distribution)
+            for ind, dwa in enumerate(data.get_data_from_dim(dim)):
+                # dwa: DataWithAxes filtered by dim
+                dwa_group = self._h5saver.get_set_group(dim_group,
+                                                        self.channel_formatter(ind), dwa.name)
+                self._data_saver.add_data(dwa_group, dwa, indexes=indexes,
+                                          distribution=distribution)
 
 
 class DataLoader:
@@ -823,7 +841,8 @@ class DataLoader:
 
         Returns
         -------
-        GROUP: returns the group named SPECIAL_GROUP_NAMES['nav_axes'] holding all NavAxis for those data
+        GROUP: returns the group named SPECIAL_GROUP_NAMES['nav_axes'] holding all NavAxis for
+        those data
 
         See Also
         --------
@@ -874,10 +893,11 @@ class DataLoader:
         for child in children_dict:
             if isinstance(children_dict[child], GROUP):
                 self.load_all(children_dict[child], data, with_bkg=with_bkg)
-            elif 'data_type' in children_dict[child].attrs and 'data' in children_dict[child].attrs['data_type']:
+            elif ('data_type' in children_dict[child].attrs and 'data' in
+                  children_dict[child].attrs['data_type']):
 
-                data_list.append(self.load_data(children_dict[child].path, with_bkg=with_bkg, load_all=True))
+                data_list.append(self.load_data(children_dict[child].path,
+                                                with_bkg=with_bkg, load_all=True))
                 break
         data_tmp = DataToExport(name=where.name, data=data_list)
         data.append(data_tmp)
-

pymodaq-4.1.1/src/pymodaq/utils/h5modules/h5logging.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 15/11/2022
+
+@author: Sebastien Weber
+"""
+
+import logging
+import numpy as np
+
+from pymodaq.utils.logger import set_logger, get_module_name
+from pymodaq.utils.config import Config
+from pymodaq.utils.managers.modules_manager import ModulesManager
+from pymodaq.utils.h5modules import module_saving, data_saving
+
+from pymodaq.utils.abstract.logger import AbstractLogger
+from pymodaq.utils import daq_utils as utils
+from .saving import H5Saver
+from pymodaq.utils.data import DataToExport
+
+
+config = Config()
+
+logger = set_logger(get_module_name(__file__))
+
+
+class H5LogHandler(logging.StreamHandler):
+    def __init__(self, h5saver):
+        super().__init__()
+        self.h5saver = h5saver
+        formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+        self.setFormatter(formatter)
+
+    def emit(self, record):
+        msg = self.format(record)
+        self.h5saver.add_log(msg)
+
+
+class H5Logger(AbstractLogger):
+    def __init__(self, modules_manager, *args, **kwargs):
+
+        self.title = self.__class__.__name__
+
+        self.modules_manager: ModulesManager = modules_manager
+        self.h5saver = H5Saver(*args, save_type='logger', **kwargs)
+
+        self.module_and_data_saver = module_saving.LoggerSaver(self)
+        for det in self.modules_manager.detectors_all:
+            det.module_and_data_saver = module_saving.DetectorEnlargeableSaver(det)
+        self.module_and_data_saver.h5saver = self.h5saver  # will update its h5saver and all submodules's h5saver
+
+    def close(self):
+        self.h5saver.close_file()
+
+    @property
+    def settings_tree(self):
+        return self.h5saver.settings_tree
+
+    @property
+    def settings(self):
+        return self.h5saver.settings
+
+    def init_logger(self, settings):
+        self.h5saver.init_file(update_h5=True, metadata=dict(settings=settings))
+        self.h5saver.flush()
+        self.module_and_data_saver.h5saver = self.h5saver
+        logger_node = self.module_and_data_saver.get_set_node(new=True)
+        return True
+
+    def get_handler(self):
+        return H5LogHandler(self.h5saver)
+
+    def add_detector(self, name, settings):
+        pass
+
+    def add_actuator(self, name, settings):
+        pass
+
+    def add_data(self, dte: DataToExport):
+        self.module_and_data_saver.add_data(dte)
+
+        self.settings.child('N_saved').setValue(self.settings.child('N_saved').value() + 1)
+
+    def stop_logger(self):
+        self.h5saver.flush()

{pymodaq-4.1.0 → pymodaq-4.1.1}/src/pymodaq/utils/h5modules/module_saving.py

@@ -361,7 +361,8 @@ class ScanSaver(ModuleSaver):
         for detector in self._module.modules_manager.detectors:
             detector.module_and_data_saver.add_nav_axes(self._module_group, axes)
 
-    def add_data(self, indexes: Tuple[int] = None, distribution=DataDistribution['uniform']):
+    def add_data(self, dte: DataToExport = None, indexes: Tuple[int] = None,
+                 distribution=DataDistribution['uniform']):
         for detector in self._module.modules_manager.detectors:
             try:
                 detector.insert_data(indexes, where=self._module_group, distribution=distribution)
@@ -381,20 +382,18 @@ class LoggerSaver(ScanSaver):
     """
     group_type = GroupType['data_logger']
 
-    def __init__(self, module):
-        self._module_group: GROUP = None
-        self._module: H5Logger = module
-        self._h5saver = None
-
-    def add_data(self):
-        for detector in self._module.modules_manager.detectors:
-            try:
-                detector.append_data(data=None, where=self._module_group)
-            except Exception as e:
-                pass
+    def add_data(self, dte: DataToExport):
+        """Add data to it's corresponding control module
 
-        for actuator in self._module.modules_manager.actuators:
-            try:
-                actuator.append_data(data=None, where=self._module_group)
-            except Exception as e:
-                pass
+        The name of the control module is the DataToExport name attribute
+        """
+        if dte.name in self._module.modules_manager.detectors_name:
+            control_module = self._module.modules_manager.detectors[
+                self._module.modules_manager.detectors_name.index(dte.name)]
+        elif dte.name in self._module.modules_manager.actuators_name:
+            control_module = self._module.modules_manager.actuators[
+                self._module.modules_manager.actuators_name.index(dte.name)]
+        else:
+            return
+
+        control_module.append_data(dte=dte, where=self._module_group)