pymodaq 5.1.6__py3-none-any.whl

pymodaq/extensions/data_mixer/model.py

@@ -0,0 +1,108 @@
+import dataclasses
+from typing import List, TYPE_CHECKING
+import importlib
+import inspect
+import pkgutil
+import warnings
+from pathlib import Path
+from typing import Union, List
+
+import numpy as np  # to be imported within models
+
+from pymodaq_utils.utils import find_dict_in_list_from_key_val, get_entrypoints
+from pymodaq_utils.logger import set_logger, get_module_name
+
+from pymodaq_data.data import DataToExport
+
+from pymodaq_gui.managers.parameter_manager import ParameterManager, Parameter
+from pymodaq_gui.config_saver_loader import ConfigSaverLoader
+
+
+logger = set_logger(get_module_name(__file__))
+
+if TYPE_CHECKING:
+    from pymodaq.extensions.data_mixer import DataMixer
+    from pymodaq.utils.managers.modules_manager import ModulesManager
+
+
+class DataMixerModel:
+
+    detectors_name: List[str] = []
+    params = []
+
+    def __init__(self, data_mixer: 'DataMixer'):
+        self.data_mixer = data_mixer
+        self.modules_manager: ModulesManager = data_mixer.modules_manager
+        self.settings: Parameter = self.data_mixer.settings.child('models', 'model_params')
+
+
+    def ini_model_base(self):
+        """ Method to add things that should be executed before instantiating the model"""
+        self.ini_model()
+
+    def ini_model(self):
+        pass
+
+    def update_settings(self, param: Parameter):
+        pass
+
+    def process_dte(self, measurements: DataToExport) -> DataToExport:
+        """
+        Convert the measurements in the units to be fed to the PID (same dimensionality as the setpoint)
+        Parameters
+        ----------
+        measurements: DataToExport
+         DataToExport object from which the model extract a value of the same units as the setpoint
+
+        Returns
+        -------
+        DataToExport: the converted input as 0D DataCalculated stored in a DataToExport
+        """
+        raise NotImplementedError
+
+
+@dataclasses.dataclass
+class PkgMock:
+    value: str
+
+
+def get_models(model_name=None) -> list[dict[(str, str), (str, type)]]:
+    """
+    Get DataMixer Models
+
+    Returns
+    -------
+    list: list of dict containing the name and python module of the found models
+
+    Example
+    -------
+    model = [{'name': 'MyModel', 'class': DataModel}]
+    """
+    models_import = []
+    discovered_models = list(get_entrypoints(group='pymodaq.models'))
+    discovered_models.append(PkgMock('pymodaq.extensions.data_mixer'))
+    if len(discovered_models) > 0:
+        for pkg in discovered_models:
+            try:
+                module = importlib.import_module(pkg.value)
+                module_name = pkg.value
+
+                for mod in pkgutil.iter_modules([str(Path(module.__file__).parent.joinpath('models'))]):
+                    try:
+                        model_module = importlib.import_module(f'{module_name}.models.{mod.name}', module)
+                        classes = inspect.getmembers(model_module, inspect.isclass)
+                        for name, klass in classes:
+                            if klass.__base__ is DataMixerModel:
+                                models_import.append({'name': mod.name, 'module': model_module, 'class': klass})
+                                break
+
+                    except Exception as e:  # pragma: no cover
+                        logger.warning(str(e))
+
+            except Exception as e:  # pragma: no cover
+                logger.warning(f'Impossible to import the {pkg.value} extension: {str(e)}')
+
+    if model_name is None:
+        return models_import
+    else:
+        return find_dict_in_list_from_key_val(models_import, 'name', model_name)

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

@@ -0,0 +1,9 @@
+from pymodaq_gui.h5modules.h5browser import main, H5Browser  #backcompat
+from pymodaq_utils.utils import deprecation_msg
+
+
+deprecation_msg('H5Browser should now be loaded from the pymodaq_gui.h5modules.h5browser module')
+
+
+if __name__ == '__main__':
+    main()