pymodaq_data 0.0.1__py3-none-any.whl

pymodaq_data/plotting/plotter/plotters/matplotlib_plotters.py

@@ -0,0 +1,133 @@
+from typing import List, Tuple, Any, TYPE_CHECKING, Union
+import sys
+import datetime
+
+import numpy as np
+
+from pymodaq_utils.logger import set_logger, get_module_name
+from pymodaq_utils import config as configmod
+from pymodaq_data.data import DataDim, DataWithAxes, DataToExport
+from pymodaq_utils import utils
+from pymodaq_data.plotting.plotter.plotter import PlotterBase, PlotterFactory
+
+from matplotlib import pyplot as plt
+
+if TYPE_CHECKING:
+    pass
+
+logger = set_logger(get_module_name(__file__))
+config = configmod.Config()
+
+PLOT_COLORS = utils.plot_colors.copy()
+PLOT_COLORS.remove((255, 255, 255))  # remove white color as plotted on white background
+PLOT_COLORS = [(np.array(color) / 255).tolist() for color in PLOT_COLORS]  # translation to matplotlib
+
+
+@PlotterFactory.register()
+class Plotter(PlotterBase):
+    backend = 'matplotlib'
+
+    def __init__(self, **_ignored):
+        super().__init__()
+        self.n_lines = 1
+        self.n_columns = 1
+        self.ind_line = 0
+        self.ind_column = 0
+
+    def plot(self, data: Union[DataWithAxes, DataToExport], *args, viewer=None,
+             **kwargs) -> plt.Figure:
+        fig = plt.figure()
+
+        if isinstance(data, DataWithAxes):
+            self.n_columns = len(data) if data.dim.name == 'Data2D' else 1
+            self.plot_dwa(data, *args, **kwargs)
+        elif isinstance(data, DataToExport):
+            self.n_columns = max([len(dwa) if dwa.dim.name == 'Data2D' else 1 for dwa in data])
+            self.n_lines = len(data)
+            self.plot_dte(data, *args, **kwargs)
+        plt.tight_layout()
+        fig.suptitle(f'{data.name} taken the {datetime.datetime.fromtimestamp(data.timestamp)}')
+        return fig
+
+    def plot_dwa(self, dwa: DataWithAxes, *args, **kwargs):
+        if dwa.dim.name == 'Data1D':
+            if len(dwa.axes) == 0:
+                dwa.create_missing_axes()
+            self.ind_column = 0
+            self.plot1D(dwa, *args, **kwargs)
+        elif dwa.dim.name == 'Data2D':
+            if len(dwa.axes) < 2:
+                dwa.create_missing_axes()
+            self.plot2D(dwa, *args, **kwargs)
+
+    def plot_dte(self, dte: DataToExport, *args, **kwargs):
+        for ind in range(len(dte)):
+            self.ind_line = ind
+            self.plot_dwa(dte[ind], *args, **kwargs)
+
+    def plot1D(self, dwa: DataWithAxes, *args, **kwargs):
+        plt.subplot(self.n_lines, self.n_columns,
+                    (self.n_columns * self.ind_line) + 1)
+        for ind_data, data_array in enumerate(dwa):
+            plt.plot(dwa.axes[0].get_data(), data_array, *args,  color=PLOT_COLORS[ind_data],
+                     **kwargs)
+            if dwa.errors is not None:
+                plt.fill_between(dwa.axes[0].get_data(), data_array - dwa.get_error(ind_data),
+                                 data_array + dwa.get_error(ind_data), *args,
+                                 color=PLOT_COLORS[ind_data] + [0.3], **kwargs)
+        plt.legend(dwa.labels)
+        #plt.title(f'{dwa.name}')
+        plt.xlabel(f'{dwa.axes[0].label} ({dwa.axes[0].units})')
+        plt.ylabel(dwa.name)
+
+    def plot2D(self, dwa: DataWithAxes, *args, **kwargs):
+        xaxis = dwa.get_axis_from_index(1)[0]
+        yaxis = dwa.get_axis_from_index(0)[0]
+
+        x = xaxis.get_data()
+        y = yaxis.get_data()
+        for ind_plot, dwa_array in enumerate(dwa):
+            self.ind_column = ind_plot
+            plt.subplot(self.n_lines, self.n_columns,
+                        (self.n_columns * self.ind_line) + ind_plot + 1)
+            X, Y = np.meshgrid(x, y)
+            plt.pcolormesh(X, Y, dwa_array, *args, **kwargs)
+            plt.title(f'{dwa.name}/{dwa.labels[ind_plot]}')
+            plt.xlabel(f'{xaxis.label} ({xaxis.units})')
+            plt.ylabel(f'{yaxis.label} ({yaxis.units})')
+
+
+# if __name__ == '__main__':
+#     from pymodaq.utils import data as data_mod
+#     import numpy as np
+#     from pymodaq.utils.math_utils import gauss1D, gauss2D
+#     from pymodaq.utils.plotting.plotter.plotter import PlotterFactory
+#     plotter_factory = PlotterFactory()
+#
+#     x = np.linspace(0, 100, 101)
+#     y = np.linspace(0, 100, 101)
+#     y1 = gauss2D(x, 50, 20, y, 40, 7)
+#
+#
+#     QtWidgets.QApplication.processEvents()
+#     dwa = data_mod.DataRaw('mydata', data=[y1, y1, y1],
+#                            axes=[data_mod.Axis('xaxis', 'x units', data=x, index=0,
+#                                                 spread_order=0),
+#                                   data_mod.Axis('yaxis', 'y units', data=y, index=1,
+#                                                 spread_order=0)
+#                                   ],
+#                            labels=['MAG', 'PHASE'],
+#                            nav_indexes=())
+#     dte = dwa.as_dte('mydte')
+#     dwa_mean = dwa.mean()
+#     dwa_mean.name = 'mean'
+#     dwa_mean_2 = dwa.mean(1)
+#     dwa_mean_2.name = 'mean2'
+#     dte.append(dwa_mean)
+#     dte.append(dwa_mean_2)
+#
+#     fig = dwa.plot('matplotlib')
+#     fig.savefig('myplot.png')
+#
+#     fig2 = dte.plot('matplotlib')
+#     fig2.savefig('mydte.png')

pymodaq_data/post_treatment/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 27/10/2022
+
+@author: Sebastien Weber
+"""

pymodaq_data/post_treatment/process_to_scalar.py

@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 04/11/2022
+
+@author: Sebastien Weber
+"""
+import numpy as np
+from numbers import Number
+from typing import List, Tuple
+from abc import ABCMeta, abstractmethod, abstractproperty
+
+from pymodaq_utils.factory import ObjectFactory
+from pymodaq_utils import math_utils as mutils
+from pymodaq_data.data import DataWithAxes, Axis, DataRaw, DataBase, DataDim, DataCalculated
+
+
+config_processors = {
+}
+
+
+class DataProcessorBase(metaclass=ABCMeta):
+    """Apply processing functions to signal data. This function should return a DataWithAxes.
+
+    Attributes
+    ----------
+    apply_to: DataDim
+        Specify on which type of data dimensionality this processor can be applied to, if only 1D:
+        apply_to = DataDim['Data1D']
+
+    """
+
+    apply_to: DataDim = abstractproperty
+
+    def process(self, data: DataWithAxes) -> DataWithAxes:
+        return self.operate(data)
+
+    @abstractmethod
+    def operate(self, sub_data: DataWithAxes):
+        pass
+
+    @staticmethod
+    def flatten_signal_dim(sub_data: DataWithAxes) -> Tuple[Tuple, np.ndarray]:
+        """flattens data's ndarrays along the signal dimensions"""
+        data_arrays = []
+        new_shape = [sub_data.shape[ind] for ind in sub_data.nav_indexes]
+        new_shape.append(np.prod([sub_data.shape[ind] for ind in sub_data.sig_indexes]))
+
+        # for each data in subdata, apply the function, here argmax, along the flattened dimension. Then unravel the
+        # possible multiple indexes (1 for 1D, 2 for 2D)
+        for ind, data in enumerate(sub_data):
+            data_arrays.append(data.reshape(new_shape))
+        return new_shape, data_arrays
+
+    def __call__(self, **kwargs):
+        return self(**kwargs)
+
+
+class DataProcessorFactory(ObjectFactory):
+    def get(self, processor_name, **kwargs) -> DataProcessorBase:
+        return self.create(processor_name, **kwargs)
+
+    @property
+    def functions(self):
+        """Get the list of processor functions"""
+        return self.keys_function(do_sort=False)
+
+    def functions_filtered(self, dim: DataDim):
+        """Get the list of processor functions that could be applied to data having a given dimensionality"""
+        return [key for key in self.functions if self.get(key).apply_to >= dim]
+
+
+@DataProcessorFactory.register('mean')
+class MeanProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        data_arrays = [np.atleast_1d(np.mean(data, axis=sub_data.sig_indexes)) for data in sub_data]
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+
+
+@DataProcessorFactory.register('std')
+class StdProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        data_arrays = [np.atleast_1d(np.std(data, axis=sub_data.sig_indexes)) for data in sub_data]
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+
+
+@DataProcessorFactory.register('sum')
+class SumProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        data_arrays = [np.atleast_1d(np.sum(data, axis=sub_data.sig_indexes)) for data in sub_data]
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+
+
+@DataProcessorFactory.register('max')
+class MaxProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        data_arrays = [np.atleast_1d(np.max(data, axis=sub_data.sig_indexes)) for data in sub_data]
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+
+
+@DataProcessorFactory.register('min')
+class MinProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        data_arrays = [np.atleast_1d(np.min(data, axis=sub_data.sig_indexes)) for data in sub_data]
+        return sub_data.deepcopy_with_new_data(data_arrays, sub_data.sig_indexes)
+
+
+@DataProcessorFactory.register('argmax')
+class ArgMaxProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        """Extract info from sub-DataWithAxes
+
+        Retrieve the signal axis values of the maximum position of the data
+
+        Notes
+        -----
+        For more complex processors, such as the argmin, argmax ... , one cannot use directly the numpy function
+        (compared to min, max, mean...). Indeed one has to first flatten the data arrays on the signal axes, then apply
+        the function on the flatten dimension, here get the indexes of the minimum along the flattened dimension (as
+        a function of the eventual navigations dimensions). From this index, on then obtain as many indexes as signal
+        dimensions (1 for 1D Signals, 2 for 2D signals). And we do this for as many data there is in sub_data.
+        """
+        new_data_arrays = []
+        new_shape, flattened_arrays = self.flatten_signal_dim(sub_data)
+
+        for dat in flattened_arrays:
+            indexes = np.unravel_index(np.nanargmax(dat, len(new_shape)-1), sub_data.shape)[len(sub_data.nav_indexes):]
+            # from the unraveled index, retrieve the corresponding axis value
+            for ind in range(len(indexes)):
+                axis_data = sub_data.get_axis_from_index(sub_data.sig_indexes[ind])[0].get_data()
+                new_data_arrays.append(np.atleast_1d(axis_data[indexes[ind]]))
+        return DataCalculated('processed_data', data=new_data_arrays, nav_indexes=sub_data.nav_indexes,
+                              axes=[axis for axis in sub_data.axes if axis.index in sub_data.nav_indexes],
+                              distribution=sub_data.distribution)
+
+
+@DataProcessorFactory.register('argmin')
+class ArgMinProcessor(DataProcessorBase):
+    apply_to = DataDim['DataND']
+
+    def operate(self, sub_data: DataWithAxes):
+        """Extract info from sub-DataWithAxes
+
+        Retrieve the signal axis values of the minimum position of the data
+
+        Notes
+        -----
+        For more complex processors, such as the argmin, argmax ... , one cannot use directly the numpy function
+        (compared to min, max, mean...). Indeed one has to first flatten the data arrays on the signal axes, then apply
+        the function on the flatten dimension, here get the indexes of the minimum along the flattened dimension (as
+        a function of the eventual navigations dimensions). From this index, on then obtain as many indexes as signal
+        dimensions (1 for 1D Signals, 2 for 2D signals). And we do this for as many data there is in sub_data.
+        """
+        new_data_arrays = []
+        new_shape, flattened_arrays = self.flatten_signal_dim(sub_data)
+
+        for dat in flattened_arrays:
+            indexes = np.unravel_index(np.nanargmin(dat, len(new_shape)-1), sub_data.shape)[len(sub_data.nav_indexes):]
+            # from the unraveled index, retrieve the corresponding axis value
+            for ind in range(len(indexes)):
+                axis_data = sub_data.get_axis_from_index(sub_data.sig_indexes[ind])[0].get_data()
+                new_data_arrays.append(np.atleast_1d(axis_data[indexes[ind]]))
+        return DataCalculated('processed_data', data=new_data_arrays, nav_indexes=sub_data.nav_indexes,
+                              axes=[axis for axis in sub_data.axes if axis.index in sub_data.nav_indexes],
+                              distribution=sub_data.distribution)
+
+
+@DataProcessorFactory.register('argmean')
+class ArgMeanProcessor(DataProcessorBase):
+    apply_to = DataDim['Data1D']
+
+    def operate(self, sub_data: DataWithAxes):
+        """Extract info from sub-DataWithAxes
+
+        Retrieve the signal mean axis values
+
+        Notes
+        -----
+        For more complex processors, such as the argmin, argmax ... , one cannot use directly the numpy function
+        (compared to min, max, mean...). Indeed one has to first flatten the data arrays on the signal axes, then apply
+        the function on the flatten dimension, here get the indexes of the minimum along the flattened dimension (as
+        a function of the eventual navigations dimensions). From this index, on then obtain as many indexes as signal
+        dimensions (1 for 1D Signals, 2 for 2D signals). And we do this for as many data there is in sub_data.
+        """
+        new_data_arrays = []
+        new_shape, flattened_arrays = self.flatten_signal_dim(sub_data)
+        values = sub_data.get_axis_from_index(sub_data.sig_indexes[0])[0].get_data()
+        for dat in flattened_arrays:
+            weights = dat
+            new_data_arrays.append(np.atleast_1d(np.average(values, axis=len(new_shape) - 1, weights=weights)))
+        return DataCalculated('processed_data', data=new_data_arrays, nav_indexes=sub_data.nav_indexes,
+                              axes=[axis for axis in sub_data.axes if axis.index in sub_data.nav_indexes])
+
+
+@DataProcessorFactory.register('argstd')
+class ArgStdProcessor(DataProcessorBase):
+    apply_to = DataDim['Data1D']
+
+    def operate(self, sub_data: DataWithAxes):
+        """Extract info from sub-DataWithAxes
+
+        Retrieve the signal mean axis values
+
+        Notes
+        -----
+        For more complex processors, such as the argmin, argmax ... , one cannot use directly the numpy function
+        (compared to min, max, mean...). Indeed one has to first flatten the data arrays on the signal axes, then apply
+        the function on the flatten dimension, here get the indexes of the minimum along the flattened dimension (as
+        a function of the eventual navigations dimensions). From this index, on then obtain as many indexes as signal
+        dimensions (1 for 1D Signals, 2 for 2D signals). And we do this for as many data there is in sub_data.
+        """
+        new_data_arrays = []
+        new_shape, flattened_arrays = self.flatten_signal_dim(sub_data)
+        values = sub_data.get_axis_from_index(sub_data.sig_indexes[0])[0].get_data()
+        for dat in flattened_arrays:
+            weights = dat
+            w_avg = np.atleast_1d(np.average(values, axis=len(new_shape) - 1, weights=weights))
+            new_data_arrays.append(np.atleast_1d(np.sqrt(
+                np.sum(weights * (values - w_avg) ** 2, axis=len(new_shape) - 1) /
+                np.sum(weights, axis=len(new_shape) - 1))))
+        return DataCalculated('processed_data', data=new_data_arrays, nav_indexes=sub_data.nav_indexes,
+                              axes=[axis for axis in sub_data.axes if axis.index in sub_data.nav_indexes])
+

pymodaq_data/slicing.py

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+"""
+Created the 07/11/2022
+
+@author: Sebastien Weber
+"""
+from typing import Union, List, TYPE_CHECKING
+import numpy as np
+
+if TYPE_CHECKING:
+    from pymodaq_data import DataWithAxes, Axis
+
+
+class SpecialSlicers(object):
+    """make it elegant to apply a slice to navigation or signal dimensions"""
+    def __init__(self, obj: Union['DataWithAxes', 'Axis'], is_navigation):
+        self.is_navigation = is_navigation
+        self.obj = obj
+
+    def __getitem__(self, slices) -> Union['DataWithAxes', 'Axis']:
+        return self.obj._slicer(slices, self.is_navigation)
+
+
+class SpecialSlicersData(SpecialSlicers):
+
+    def __setitem__(self, slices, data: Union[np.ndarray, 'DataWithAxes', 'Axis']):
+        """x.__setitem__(slices, data) <==> x[slices]=data
+        """
+        slices = self.obj._compute_slices(slices, self.is_navigation)
+
+        if hasattr(self.obj, 'base_type') and self.obj.base_type == 'Axis':
+            if isinstance(data, np.ndarray):
+                data_to_replace = data
+            else:
+                data_to_replace = data.get_data()
+            if hasattr(self.obj, 'units') and self.obj.data is None:
+                self.obj.create_linear_data(len(self.obj))
+            self.obj.data[slices] = data_to_replace
+        else:
+            for ind in range(len(self.obj)):
+                if isinstance(data, np.ndarray):
+                    data_to_replace = data
+                else:  # means it's a DataWithAxes
+                    data_to_replace = data[ind]
+                self.obj[ind][slices] = data_to_replace
+
+    def __len__(self):
+        return self.obj.axes_manager.sig_shape[0]

pymodaq_data-0.0.1.dist-info/METADATA

@@ -0,0 +1,160 @@
+Metadata-Version: 2.3
+Name: pymodaq_data
+Version: 0.0.1
+Summary: Modular Data Acquisition with Python
+Project-URL: Homepage, http://pymodaq.cnrs.fr
+Project-URL: Source, https://github.com/PyMoDAQ/PyMoDAQ
+Project-URL: Tracker, https://github.com/PyMoDAQ/PyMoDAQ/issues
+Author-email: Sébastien Weber <sebastien.weber@cemes.fr>
+License: The MIT License (MIT)
+        
+        Copyright (c) 2021 Sebastien Weber <sebastien.weber@cemes.fr>
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in
+        all copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+        THE SOFTWARE.
+License-File: LICENSE
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Other Environment
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: User Interfaces
+Requires-Python: >=3.8
+Requires-Dist: multipledispatch
+Requires-Dist: numpy<2.0.0
+Requires-Dist: packaging
+Requires-Dist: pint
+Requires-Dist: pymodaq-utils
+Requires-Dist: python-dateutil
+Requires-Dist: scipy
+Requires-Dist: tables<3.9
+Requires-Dist: toml
+Description-Content-Type: text/x-rst
+
+PyMoDAQ Data
+############
+
+.. image:: https://img.shields.io/pypi/v/pymodaq_data.svg
+   :target: https://pypi.org/project/pymodaq_data/
+   :alt: Latest Version
+
+.. image:: https://readthedocs.org/projects/pymodaq/badge/?version=latest
+   :target: https://pymodaq.readthedocs.io/en/stable/?badge=latest
+   :alt: Documentation Status
+
+.. image:: https://codecov.io/gh/PyMoDAQ/pymodaq_data/branch/0.0.x/graph/badge.svg?token=IQNJRCQDM2
+    :target: https://codecov.io/gh/PyMoDAQ/pymodaq_data
+
+====== ======= ======
+Python OS      Passed
+====== ======= ======
+3.8    Linux   |38|
+3.9    Linux   |39|
+3.10   Linux   |310|
+3.11   Linux   |311|
+3.12   Linux   |312|
+3.11   Windows |311win|
+====== ======= ======
+
+
+.. |38| image:: https://github.com/PyMoDAQ/pymodaq_data/actions/workflows/Testp38.yml/badge.svg?branch=0.0.x_dev
+    :target: https://github.com/PyMoDAQ/pymodaq_data/actions/workflows/Testp385.yml
+
+.. |39| image:: https://github.com/PyMoDAQ/pymodaq_data/actions/workflows/Testp39.yml/badge.svg?branch=0.0.x_dev
+    :target: https://github.com/PyMoDAQ/pymodaq_data/actions/workflows/Testp39.yml
+
+.. |310| image:: https://github.com/PyMoDAQ/pymodaq_data/actions/workflows/Testp310.yml/badge.svg?branch=0.0.x_dev
+    :target: https://github.com/PyMoDAQ/pymodaq_data/actions/workflows/Testp310.yml
+
+.. |311| image:: https://github.com/PyMoDAQ/pymodaq_data/actions/workflows/Testp311.yml/badge.svg?branch=0.0.x_dev
+    :target: https://github.com/PyMoDAQ/pymodaq_data/actions/workflows/Testp311.yml
+
+.. |312| image:: https://github.com/PyMoDAQ/pymodaq_data/actions/workflows/Testp312.yml/badge.svg?branch=0.0.x_dev
+    :target: https://github.com/PyMoDAQ/pymodaq_data/actions/workflows/Testp312.yml
+
+.. |311win| image:: https://github.com/PyMoDAQ/pymodaq_data/actions/workflows/Testp311_win.yml/badge.svg?branch=0.0.x_dev
+    :target: https://github.com/PyMoDAQ/pymodaq_data/actions/workflows/Testp311_win.yml
+
+
+
+
+.. figure:: http://pymodaq.cnrs.fr/en/latest/_static/splash.png
+   :alt: shortcut
+
+
+PyMoDAQ__, Modular Data Acquisition with Python, is a set of **python** modules used to interface any kind of
+experiments. It simplifies the interaction with detector and actuator hardware to go straight to the data acquisition
+of interest.
+
+__ https://pymodaq.readthedocs.io/en/stable/?badge=latest
+
+`PyMoDAQ data`__ is a set of utilities (constants, methods and classes) that are used
+for Data Management. It is heavily used with the PyMoDAQ framework but can also be used as a standalone
+package for data management in another context.
+
+__ https://pymodaq.cnrs.fr/en/latest/developer_folder/data_management.html
+
+What are Data?
+--------------
+
+Data are objects with many characteristics able to properly describe real data taken on an experiment
+or calculated from theory:
+
+
+*  a type: float, int, ...
+*  a dimensionality: Data0D, Data1D, Data2D and higher
+*  units (dealt with the pint python package)
+*  axes
+*  actual data as numpy arrays
+*  uncertainty/error bars
+* ...
+
+
+.. figure:: https://pymodaq.cnrs.fr/en/latest/_images/data.png
+   :alt: What is data?
+
+   What is PyMoDAQ's data?.
+
+The `PyMoDAQ Data` package
+--------------------------
+
+Because of this variety, `PyMoDAQ Data` introduce a set of objects including metadata (for instance the time of
+acquisition) and various methods and properties to manipulate
+them during analysis for instance (getting name, slicing, concatenating...),
+save them and plot them (given you installed one of the available backend: *matplotlib* or *Qt* (
+through the `pymodaq_gui` package)
+
+To learn more, check the documentation__.
+
+__ https://pymodaq.cnrs.fr/en/latest/developer_folder/data_management.html
+
+
+Published under the MIT FREE SOFTWARE LICENSE
+
+GitHub repo: https://github.com/PyMoDAQ
+
+Documentation: http://pymodaq.cnrs.fr/

pymodaq_data-0.0.1.dist-info/RECORD

@@ -0,0 +1,26 @@
+pymodaq_data/__init__.py,sha256=Eq4rIGouzYHyY3rWe1K8N4l_voPY5iRFTvW9wXI3f2E,1701
+pymodaq_data/data.py,sha256=EEfjgNHcy-yS2Bzjurod7f5EWS8SRkY3-p6DlcybWEY,106030
+pymodaq_data/icon.ico,sha256=hOHHfNDENKphQvG1WDleSEYcHukneR2eRFJu8isIlD4,74359
+pymodaq_data/slicing.py,sha256=u-PDiCUFCpVzqf25KkC9ifnuZDKay2fWpaCytph15e4,1652
+pymodaq_data/splash.png,sha256=ow8IECF3tPRUMA4tf2tMu1aRiMaxx91_Y2ckVxkrmF0,53114
+pymodaq_data/h5modules/__init__.py,sha256=x3_4ELvG9onTKEFgIt9xEGg_mA1bB07dvVbU9q0xQKw,104
+pymodaq_data/h5modules/backends.py,sha256=2svvkU_Jsqgm5XSP7uf1TlZZU8XMTgYEPgXe1d1ZYew,33798
+pymodaq_data/h5modules/browsing.py,sha256=BRaR6qAy_pYRJe9hjWgl5HfyLBJ5dnygDghFCAWkdEg,3021
+pymodaq_data/h5modules/data_saving.py,sha256=rvq9sLallgl-D-7M5ZYlpsgG3k_2TMK5FdIjYogEIjs,42570
+pymodaq_data/h5modules/exporter.py,sha256=fkHGOy8ivzQ0hgn9hDJf7G4GWdTl6AdSTCJqvqzds0A,3669
+pymodaq_data/h5modules/saving.py,sha256=ygZIccT4oprqwfkUA8C527iPS4Wbgrc6Mk90w8wwrSY,14599
+pymodaq_data/h5modules/utils.py,sha256=yrCmPE7UAgZk4lanv4zC4LjTpp_vaQz54ZCvKWl15-0,3374
+pymodaq_data/h5modules/exporters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq_data/h5modules/exporters/base.py,sha256=U2DtIewbcaOGUDx0VGlhyqVpyjrx7KNVEvcg7S4NAxE,4117
+pymodaq_data/h5modules/exporters/flimj.py,sha256=gUkbtTJGiv1LoK1WE0XZulqP9y57VWzjPaktXLmXZqs,2359
+pymodaq_data/h5modules/exporters/hyperspy.py,sha256=gAMuMEuruVgbvk59L87Yc5b7kxwjXjaYbyAWW5dqH58,6513
+pymodaq_data/plotting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq_data/plotting/plotter/plotter.py,sha256=ueH_mg9bJnHCvl4MjM-hho4jG-G_sggMRhTBA_2Ns2Q,2839
+pymodaq_data/plotting/plotter/plotters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+pymodaq_data/plotting/plotter/plotters/matplotlib_plotters.py,sha256=mUFgc2MTJTjq5jeTasP4xpB6Xli7QhOyfiK1gIVQlP8,5079
+pymodaq_data/post_treatment/__init__.py,sha256=xaaLFZJ7OLqI_7yPurFk89A7m2ywSbYDXAsdE-QQ8Zg,81
+pymodaq_data/post_treatment/process_to_scalar.py,sha256=hM2WmOesrkuWvq-BvNsZmKOz6_sZRJh97wdkVEgwqMc,10551
+pymodaq_data-0.0.1.dist-info/METADATA,sha256=ssyXLUzmKiBGJsmuMZBu31c6_k3cT0ZFfixu8sYRsAs,6508
+pymodaq_data-0.0.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+pymodaq_data-0.0.1.dist-info/licenses/LICENSE,sha256=VKOejxexXAe3XwfhAhcFGqeXQ12irxVHdeAojZwFEI8,1108
+pymodaq_data-0.0.1.dist-info/RECORD,,

pymodaq_data-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.25.0
+Root-Is-Purelib: true
+Tag: py3-none-any

pymodaq_data-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Sebastien Weber <sebastien.weber@cemes.fr>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.