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

pymodaq/extensions/data_mixer/models/equation_model.py

@@ -0,0 +1,91 @@
+from pymodaq.extensions.data_mixer.model import DataMixerModel, np  # np will be used in method eval of the formula
+
+from pymodaq_data.data import DataToExport, DataWithAxes
+from pymodaq_gui.parameter import Parameter
+from pymodaq_gui.config_saver_loader import ConfigSaverLoader
+
+from pymodaq.extensions.data_mixer.parser import (
+    extract_data_names, split_formulae, replace_names_in_formula)
+
+from pymodaq_utils.logger import set_logger, get_module_name
+
+logger = set_logger(get_module_name(__file__))
+
+class DataMixerModelEquation(DataMixerModel):
+    params = [
+        {'title': 'Get Data:', 'name': 'get_data', 'type': 'bool_push', 'value': False,
+         'label': 'Get Data'},
+        {'title': 'Edit Formula:', 'name': 'edit_formula', 'type': 'text', 'value': ''},
+        {'title': 'Data0D:', 'name': 'data0D', 'type': 'itemselect',
+         'value': dict(all_items=[], selected=[])},
+        {'title': 'Data1D:', 'name': 'data1D', 'type': 'itemselect',
+         'value': dict(all_items=[], selected=[])},
+        {'title': 'Data2D:', 'name': 'data2D', 'type': 'itemselect',
+         'value': dict(all_items=[], selected=[])},
+        {'title': 'DataND:', 'name': 'dataND', 'type': 'itemselect',
+         'value': dict(all_items=[], selected=[])},
+    ]
+
+    def ini_model(self):
+        self.model_saver_loader = ConfigSaverLoader(self.settings, self.data_mixer.datamixer_config,
+                                                    base_path=[self.__class__.__name__])
+        self.show_data_list()
+        self.model_saver_loader.load_config()
+
+    def update_settings(self, param: Parameter):
+        if param.name() == 'get_data':
+            self.show_data_list()
+        elif param.name() == 'edit_formula':
+            self.model_saver_loader.save_config(param)
+
+    def process_dte(self, dte: DataToExport):
+        formulae = split_formulae(self.get_formulae())
+        dte_processed = DataToExport('Computed')
+        for ind, formula in enumerate(formulae):
+            try:
+                dwa = self.compute_formula(formula, dte,
+                                           name=f'Formula_{ind:03.0f}')
+                dte_processed.append(dwa)
+            except Exception as e:
+                logger.exception(f'{str(e)}')
+        return dte_processed
+
+    def get_formulae(self) -> str:
+        """ Read the content of the formula QTextEdit widget"""
+        return self.settings['edit_formula']
+
+    def show_data_list(self):
+        dte = self.modules_manager.get_det_data_list()
+
+        data_list0D = dte.get_full_names('data0D')
+        data_list1D = dte.get_full_names('data1D')
+        data_list2D = dte.get_full_names('data2D')
+        data_listND = dte.get_full_names('dataND')
+
+        self.settings.child('data0D').setValue(dict(all_items=data_list0D, selected=[]))
+        self.settings.child('data1D').setValue(dict(all_items=data_list1D, selected=[]))
+        self.settings.child('data2D').setValue(dict(all_items=data_list2D, selected=[]))
+        self.settings.child('dataND').setValue(dict(all_items=data_listND, selected=[]))
+
+
+    def compute_formula(self, formula: str, dte: DataToExport,
+                        name: str) -> DataWithAxes:
+        """ Compute the operations in formula using data stored in dte
+
+        Parameters
+        ----------
+        formula: str
+            The mathematical formula using numpy and data fullnames within curly brackets
+        dte: DataToExport
+        name: str
+            The name to give to the produced DataWithAxes
+
+        Returns
+        -------
+        DataWithAxes: the results of the formula computation
+        """
+        formula_to_eval, names = replace_names_in_formula(formula)
+        dwa = eval(formula_to_eval)
+        dwa.name = name
+        return dwa
+

pymodaq/extensions/data_mixer/models/gaussian_fit_model.py

@@ -0,0 +1,65 @@
+import numpy as np
+
+from pymodaq.extensions.data_mixer.model import DataMixerModel, np  # np will be used in method eval of the formula
+
+from pymodaq_utils.math_utils import gauss1D, my_moment
+
+from pymodaq_data.data import DataToExport, DataWithAxes, DataCalculated, DataDim
+from pymodaq_gui.parameter import Parameter
+
+from pymodaq.extensions.data_mixer.parser import (
+    extract_data_names, split_formulae, replace_names_in_formula)
+
+
+def gaussian_fit(x, amp, x0, dx, offset):
+    dx = np.abs(dx)
+    return amp * gauss1D(x, x0, dx) + offset
+
+
+class DataMixerGaussianFitModel(DataMixerModel):
+    params = [
+        {'title': 'Get Data:', 'name': 'get_data', 'type': 'bool_push', 'value': False,
+         'label': 'Get Data'},
+        {'title': 'Data1D:', 'name': 'data1D', 'type': 'itemselect',
+         'value': dict(all_items=[], selected=[])},
+    ]
+
+    def ini_model(self):
+        self.show_data_list()
+
+    def show_data_list(self):
+        dte = self.modules_manager.get_det_data_list()
+        data_list1D = dte.get_full_names('data1D')
+        self.settings.child('data1D').setValue(dict(all_items=data_list1D, selected=[]))
+
+    def update_settings(self, param: Parameter):
+        if param.name() == 'get_data':
+            self.show_data_list()
+
+    def process_dte(self, dte: DataToExport):
+        dte_processed = DataToExport('computed')
+        if len(self.settings['data1D']['selected']) !=  0:
+
+            dwa = dte.get_data_from_full_name(self.settings['data1D']['selected'][0])
+            dwa_fit = dwa.fit(gaussian_fit, self.get_guess(dwa), data_index=0)
+            dwa.append(dwa_fit)
+            dte_processed.append(dwa)
+            dte_processed.append(
+                DataCalculated('Coeffs',
+                               data=[np.atleast_1d(coeff) for coeff in dwa_fit.fit_coeffs[0]],
+                               labels=['amp', 'x0', 'dx', 'offset']))
+
+        return dte_processed
+
+    @staticmethod
+    def get_guess(dwa):
+        offset = np.min(dwa).value()
+        dwa.create_missing_axes()
+        moments = my_moment(dwa.axes[0].get_data(), dwa.data[0])
+        amp = (np.max(dwa) - np.min(dwa)).value()
+        x0 = float(moments[0])
+        dx = float(moments[1])
+
+        return amp, x0, dx, offset
+
+

pymodaq/extensions/data_mixer/parser.py

@@ -0,0 +1,53 @@
+import re
+from typing import List
+
+
+data_name_regexp = re.compile(r"({.*?})+")  # first occurrences of things between {}
+
+
+def split_formulae(formulae: str) -> List[str]:
+    """ Split a string into a list of string for each new line
+
+    Parameters
+    ----------
+    formulae: str
+        The formulae containing various mathematical formula separated with a new line character
+
+    Returns
+    -------
+    The various formula as a list of string
+    """
+    return re.split(r'\n', formulae)
+
+
+def extract_data_names(formula: str) -> List[str]:
+    """ Extract the names of the data appearing between curly brackets with a given string formula
+
+    Parameters
+    ----------
+    formula: str
+        The mathematical expression to compute containing in curly brackets the data full names
+
+    Returns
+    -------
+
+    """
+    data_names = [data_name_with_curly[1:-1] for
+                  data_name_with_curly in data_name_regexp.findall(formula)]
+    return data_names
+
+
+def replace_names_in_formula(formula: str):
+    formula_tmp = formula[:]
+    names = []
+    while True:
+        m = data_name_regexp.search(formula_tmp)
+        if m is not None:
+            names.append(m.group())
+            formula_tmp = (
+                formula_tmp.replace(formula_tmp[m.start(): m.end()],
+                                    f'dte.get_data_from_full_name("{m.group()[1:-1]}")'))
+        else:
+            break
+    return formula_tmp, names
+

pymodaq/extensions/data_mixer/utils.py

@@ -0,0 +1,23 @@
+from pymodaq_utils.config import BaseConfig
+
+
+class DataMixerConfig(BaseConfig):
+    """Main class to deal with configuration values for this plugin
+
+    To b subclassed for real implementation if needed, see Optimizer class attribute config_saver
+    """
+    config_template_path = None
+    config_name = f"datamixer_settings"
+
+
+def find_key_in_nested_dict(dic, key):
+    stack = [dic]
+    while stack:
+        d = stack.pop()
+        if key in d:
+            return d[key]
+        for v in d.values():
+            if isinstance(v, dict):
+                stack.append(v)
+            if isinstance(v, list):
+                stack += v

pymodaq/extensions/h5browser.py

@@ -1,39 +1,8 @@
-import argparse
-from pathlib import Path
-import sys
-import os
-from qtpy import QtWidgets
-os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE"
-from pymodaq_gui.h5modules.browsing import H5Browser
-from pymodaq.utils.config import Config
+from pymodaq_gui.h5modules.h5browser import main, H5Browser  #backcompat
+from pymodaq_utils.utils import deprecation_msg
 
 
-config = Config()
-
-
-def main(h5file_path: Path = None):
-    from pymodaq_gui.utils.utils import mkQApp
-    import sys
-    app = mkQApp('H5Browser')
-
-    h5file_path_tmp = None
-    parser = argparse.ArgumentParser(description="Opens HDF5 files and navigate their contents")
-    parser.add_argument("-i", "--input", help="specify path to the file to be opened")
-    args = parser.parse_args()
-
-    if args.input:
-        h5file_path_tmp = Path(args.input).resolve()  # Transform to absolute Path in case it is relative
-
-        if not h5file_path_tmp.exists():
-            print(f'Error: {args.input} does not exist. Opening h5browser without input file.')
-            h5file_path_tmp = h5file_path
-
-    win = QtWidgets.QMainWindow()
-    prog = H5Browser(win, h5file_path=h5file_path_tmp)
-    win.show()
-    QtWidgets.QApplication.processEvents()
-
-    app.exec()
+deprecation_msg('H5Browser should now be loaded from the pymodaq_gui.h5modules.h5browser module')
 
 
 if __name__ == '__main__':