pymodaq 3.6.12__py3-none-any.whl → 4.0.1__py3-none-any.whl

pymodaq/daq_utils/h5utils.py

@@ -1,241 +0,0 @@
-# Standard imports
-from collections import OrderedDict
-from typing import List, Dict
-
-# 3rd party imports
-import numpy as np
-
-# project imports
-from pymodaq.daq_utils.h5backend import Node
-from pymodaq.daq_utils.daq_utils import set_logger, get_module_name
-from pymodaq.daq_utils.daq_utils import capitalize, Axis, NavAxis
-
-logger = set_logger(get_module_name(__file__))
-
-
-# Normally, this function does not rely on a H5Backend object so this is good
-def find_scan_node(scan_node: Node):
-    """
-    utility function to find the parent node of "scan" type, meaning some of its children (DAQ_scan case)
-    or co-nodes (daq_logger case) are navigation axes
-    Parameters
-    ----------
-    scan_node: (pytables node)
-        data node from where this function look for its navigation axes if any
-    Returns
-    -------
-    node: the parent node of 'scan' type
-    list: the data nodes of type 'navigation_axis' corresponding to the initial data node
-
-    """
-    try:
-        while True:
-            if scan_node.attrs['type'] == 'scan':
-                break
-            else:
-                scan_node = scan_node.parent_node
-        children = list(scan_node.children().values())  # for data saved using daq_scan
-        # How is it any different from list(scan_node.parent_node.children().values()) ???
-        children.extend([scan_node.parent_node.children()[child] for child in
-                         scan_node.parent_node.children_name()])  # for data saved using the daq_logger
-        nav_children = []
-        for child in children:
-            if 'type' in child.attrs.attrs_name:
-                if child.attrs['type'] == 'navigation_axis':
-                    nav_children.append(child)
-        return scan_node, nav_children
-    except Exception:
-        return None, []
-
-
-def get_h5_attributes(self, node_path):
-    """
-
-        """
-    node = self.get_node(node_path)
-    attrs_names = node.attrs.attrs_name
-    attr_dict = OrderedDict([])
-    for attr in attrs_names:
-        # if attr!='settings':
-        attr_dict[attr] = node.attrs[attr]
-
-    settings = None
-    scan_settings = None
-    if 'settings' in attrs_names:
-        if node.attrs['settings'] != '':
-            settings = node.attrs['settings']
-
-    if 'scan_settings' in attrs_names:
-        if node.attrs['scan_settings'] != '':
-            scan_settings = node.attrs['scan_settings']
-    pixmaps = []
-    for attr in attrs_names:
-        if 'pixmap' in attr:
-            pixmaps.append(node.attrs[attr])
-
-    return attr_dict, settings, scan_settings, pixmaps
-
-
-# This is a get_h5_data rewritten to remove dependency on a H5Backend object
-def get_h5_data_from_node(node: Node) -> (np.ndarray, Dict[str, Axis], List[Axis], bool):
-    """Check if there exist a data in the node, and if yes get the relevant axes.
-    """
-
-    is_spread = False
-    # checks If the node contains an array. Effectively, if the node is a 'CARRAY', 'EARRAY' etc.
-    # if that's not the case we return some empty data
-    if 'ARRAY' not in node.attrs['CLASS']:
-        logger.warning(f'node {node} does not host a dataset.')
-        return np.array([]), [], [], is_spread
-
-    # Otherwise Axis node is an ARRAY subclass which implements read() and has a GROUP parent node
-    data = node.read()
-    nav_axes = []
-    axes = dict([])
-    if isinstance(data, np.ndarray):
-        data = np.squeeze(data)
-        if 'Bkg' in node.parent_node.children_name() and node.name != 'Bkg':
-            parent_group = node.parent_node  # This should be a group object if I get how this works
-            # Then the parent node should have a children method which alllows to get the background.
-            bkg_node = parent_group.children()['Bkg']
-            bkg = np.squeeze(bkg_node.read())
-            # bkg = np.squeeze(self.get_node(node.parent_node.path, 'Bkg').read())
-            try:
-                data = data - bkg
-            except ValueError:
-                logger.warning(f'Could not substract bkg from data node {node} as their shape are '
-                               f'incoherent {bkg.shape} and {data.shape}')
-        if 'type' in node.attrs.attrs_name:
-            if 'data' in node.attrs['type'] or 'channel' in node.attrs['type'].lower():
-                # parent_path = node.parent_node.path
-                children_names = node.parent_node.children_name()
-
-                if 'data_dimension' not in node.attrs.attrs_name:  # for backcompatibility
-                    data_dim = node.attrs['data_type']
-                else:
-                    data_dim = node.attrs['data_dimension']
-                if 'scan_subtype' in node.attrs.attrs_name:
-                    if node.attrs['scan_subtype'].lower() == 'adaptive':
-                        is_spread = True
-                tmp_axes = ['x_axis', 'y_axis']
-                for ax in tmp_axes:
-                    if capitalize(ax) in children_names:
-                        # Following the same logic as before we should be able to apply this
-                        axis_node = node.parent_node.children()[capitalize(ax)]
-                        # axis_node = self.get_node(parent_path + '/{:s}'.format(capitalize(ax)))
-                        axes[ax] = Axis(data=axis_node.read())
-                        if 'units' in axis_node.attrs.attrs_name:
-                            axes[ax]['units'] = axis_node.attrs['units']
-                        if 'label' in axis_node.attrs.attrs_name:
-                            axes[ax]['label'] = axis_node.attrs['label']
-                    else:
-                        axes[ax] = Axis()
-
-                if data_dim == 'ND':  # check for navigation axis
-                    tmp_nav_axes = ['y_axis', 'x_axis', ]
-                    nav_axes = []
-                    for ind_ax, ax in enumerate(tmp_nav_axes):
-                        if 'Nav_{:s}'.format(ax) in children_names:
-                            nav_axes.append(ind_ax)
-                            axis_node = node.parent_node.children()[f"Nav_{ax}"]
-                            # axis_node = self.get_node(parent_path + '/Nav_{:s}'.format(ax))
-                            if is_spread:
-                                axes['nav_{:s}'.format(ax)] = Axis(data=axis_node.read())
-                            else:
-                                axes['nav_{:s}'.format(ax)] = Axis(data=np.unique(axis_node.read()))
-                                if axes['nav_{:s}'.format(ax)]['data'].shape[0] != data.shape[ind_ax]:
-                                    # could happen in case of linear back to start type of scan
-                                    tmp_ax = []
-                                    for ix in axes['nav_{:s}'.format(ax)]['data']:
-                                        tmp_ax.extend([ix, ix])
-                                        axes['nav_{:s}'.format(ax)] = Axis(data=np.array(tmp_ax))
-
-                            if 'units' in axis_node.attrs.attrs_name:
-                                axes['nav_{:s}'.format(ax)]['units'] = axis_node.attrs['units']
-                            if 'label' in axis_node.attrs.attrs_name:
-                                axes['nav_{:s}'.format(ax)]['label'] = axis_node.attrs['label']
-
-                if 'scan_type' in node.attrs.attrs_name:
-                    scan_type = node.attrs['scan_type'].lower()
-                    # if scan_type == 'scan1d' or scan_type == 'scan2d':
-                    scan_node, nav_children = find_scan_node(node)
-                    nav_axes = []
-                    if scan_type == 'tabular' or is_spread:
-                        datas = []
-                        labels = []
-                        all_units = []
-                        npts = 2  # Just in case nav_children is empty
-                        for axis_node in nav_children:
-                            npts = axis_node.attrs['shape'][0]
-                            datas.append(axis_node.read())
-                            labels.append(axis_node.attrs['label'])
-                            all_units.append(axis_node.attrs['units'])
-
-                        nav_axes.append(0)
-                        axes['nav_x_axis'] = NavAxis(
-                            data=np.linspace(0, npts - 1, npts),
-                            nav_index=nav_axes[-1], units='', label='Scan index', labels=labels,
-                            datas=datas, all_units=all_units)
-                    else:
-                        for axis_node in nav_children:
-                            nav_axes.append(axis_node.attrs['nav_index'])
-                            if is_spread:
-                                axes[f'nav_{nav_axes[-1]:02d}'] = NavAxis(data=axis_node.read(),
-                                                                          nav_index=nav_axes[-1])
-                            else:
-                                axes[f'nav_{nav_axes[-1]:02d}'] = NavAxis(data=np.unique(axis_node.read()),
-                                                                          nav_index=nav_axes[-1])
-                                if nav_axes[-1] < len(data.shape):
-                                    if axes[f'nav_{nav_axes[-1]:02d}']['data'].shape[0] != data.shape[nav_axes[-1]]:
-                                        # could happen in case of linear back to start type of scan
-                                        tmp_ax = []
-                                        for ix in axes[f'nav_{nav_axes[-1]:02d}']['data']:
-                                            tmp_ax.extend([ix, ix])
-                                            axes[f'nav_{nav_axes[-1]:02d}'] = NavAxis(data=np.array(tmp_ax),
-                                                                                      nav_index=nav_axes[-1])
-
-                            if 'units' in axis_node.attrs.attrs_name:
-                                axes[f'nav_{nav_axes[-1]:02d}']['units'] = axis_node.attrs[
-                                    'units']
-                            if 'label' in axis_node.attrs.attrs_name:
-                                axes[f'nav_{nav_axes[-1]:02d}']['label'] = axis_node.attrs[
-                                    'label']
-            elif 'axis' in node.attrs['type']:
-                axis_node = node
-                axes['y_axis'] = Axis(data=axis_node.read())  # Axis node should be CARRAY which implements read()
-                if 'units' in axis_node.attrs.attrs_name:
-                    axes['y_axis']['units'] = axis_node.attrs['units']
-                if 'label' in axis_node.attrs.attrs_name:
-                    axes['y_axis']['label'] = axis_node.attrs['label']
-                axes['x_axis'] = Axis(
-                    data=np.linspace(0, axis_node.attrs['shape'][0] - 1, axis_node.attrs['shape'][0]),
-                    units='pxls',
-                    label='')
-        return data, axes, nav_axes, is_spread
-
-    elif isinstance(data, list):
-        data = np.array(data)
-        return data, dict([]), [], is_spread
-
-def extract_axis(ax: Axis) -> np.ndarray:
-    """Extract the unique values in a PyMoDAQ axis object in an order-preserving way"""
-    axis_data = ax.data
-    _, idx = np.unique(axis_data, return_index=True)
-
-    unique_ax = axis_data[np.sort(idx)]
-
-    return unique_ax
-
-def verify_axis_data_uniformity(axis_data: np.ndarray, tol: float = 1e-6) -> (float, float):
-    """Try fitting the axis data with an affine function. Return offset,slope if the
-     result is within tolerances, otherwise return None, None"""
-    slope = None
-    offset = None
-
-    index = np.arange(len(axis_data))
-    res, residuals, rank, singular_values, rcond = np.polyfit(x=index, y=axis_data, deg=1, full=True)  # noqa
-    if residuals[0] < tol:
-        slope = res[0]
-        offset = res[1]
-
-    return offset, slope

pymodaq/daq_utils/managers/action_manager.py

@@ -1,236 +0,0 @@
-import pymodaq.daq_utils.messenger
-from multipledispatch import dispatch
-from qtpy import QtGui, QtWidgets, QtCore
-
-from qtpy.QtWidgets import QAction
-
-from pymodaq.resources.QtDesigner_Ressources import QtDesigner_ressources_rc
-from pathlib import Path
-
-
-class QAction(QAction):
-    """
-    QAction subclass to mimic signals as pushbuttons. Done to be sure of backcompatibility when I moved from
-    pushbuttons to QAction
-    """
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
-    def click(self):
-        pymodaq.daq_utils.messenger.deprecation_msg("click for PyMoDAQ's QAction is deprecated, use *trigger*",
-                                                    stacklevel=3)
-        self.trigger()
-
-    @property
-    def clicked(self):
-        pymodaq.daq_utils.messenger.deprecation_msg("clicked for PyMoDAQ's QAction is deprecated, use *trigger*",
-                                                    stacklevel=3)
-        return self.triggered
-
-    def connect_to(self, slot):
-        self.triggered.connect(slot)
-
-
-def addaction(name='', icon_name='', tip='', checkable=False, slot=None, toolbar=None, menu=None):
-    """Create a new action and add it eventually to a toolbar and a menu
-    Parameters
-    ----------
-    name: (str) Displayed name if should be displayed (for instance in menus)
-    icon_name: (str) png file name to produce the icon
-    tip: (str) a tooltip to be displayed when hovering above the action
-    checkable: (bool) set the checkable state of the action
-    slot: (callable) Method or function that will be called when the action is triggered
-    toolbar: (QToolBar) a toolbar where action should be added.
-    menu: (QMenu) a menu where action should be added.
-    """
-    if icon_name != '':
-        icon = QtGui.QIcon()
-        if Path(icon_name).is_file():
-            icon.addPixmap(QtGui.QPixmap(icon_name), QtGui.QIcon.Normal,
-                           QtGui.QIcon.Off)
-        else:
-            icon.addPixmap(QtGui.QPixmap(f":/icons/Icon_Library/{icon_name}.png"), QtGui.QIcon.Normal,
-                           QtGui.QIcon.Off)
-        action = QAction(icon, name, None)
-    else:
-        action = QAction(name)
-
-    if slot is not None:
-        action.connect_to(slot)
-    action.setCheckable(checkable)
-    action.setToolTip(tip)
-    if toolbar is not None:
-        toolbar.addAction(action)
-    if menu is not None:
-        menu.addAction(action)
-    return action
-
-
-class ActionManager:
-    """MixIn Class to be used by all UserInterface to manage their QActions and the action they are connected to"""
-    def __init__(self, toolbar=None, menu=None):
-        self._actions = dict([])
-        self._toolbar = toolbar
-        self._menu = menu
-
-        #self.setup_actions()
-
-    def setup_actions(self):
-        """
-        self.add_action('Quit', 'close2', "Quit program")
-        self.add_action('Grab', 'camera', "Grab from camera", checkable=True)
-        self.add_action('Load', 'Open', "Load target file (.h5, .png, .jpg) or data from camera", checkable=False)
-        self.add_action('Save', 'SaveAs', "Save current data", checkable=False)
-
-        See Also
-        --------
-        ActionManager.add_action
-        """
-        raise NotImplementedError(f'You have to define actions here in the following form:'
-                                  f'{self.setup_actions.__doc__}')
-
-    def add_action(self, short_name='', name='', icon_name='', tip='', checkable=False, toolbar=None, menu=None):
-        """Create a new action and add it to toolbar and menu
-        Parameters
-        ----------
-        short_name: (str) the name as referenced in the dict self.actions
-        name: (str) Displayed name if should be displayed in
-        icon_name: (str) png file name to produce the icon
-        tip: (str) a tooltip to be displayed when hovering above the action
-        checkable: (bool) set the checkable state of the action
-        toolbar: (QToolBar) a toolbar where action should be added. Actions can also be added later see *affect_to*
-        menu: (QMenu) a menu where action should be added. Actions can also be added later see *affect_to*
-
-        See Also
-        --------
-        affect_to: method to affect an action to a toolbar or manu
-        pymodaq.resources.QtDesigner_Ressources.Icon_Library: resource for icons png
-        pymodaq.daq_utils.managers.action_manager.add_action: base method used here
-        """
-        if toolbar is None:
-            toolbar = self._toolbar
-        if menu is None:
-            menu = self._menu
-        self._actions[short_name] = addaction(name, icon_name, tip, checkable=checkable, toolbar=toolbar, menu=menu)
-
-    def set_toolbar(self, toolbar):
-        """
-        affect a toolbar to self
-        Parameters
-        ----------
-        toolbar: (QtWidgets.QToolBar)
-
-        """
-        self._toolbar = toolbar
-
-    def set_menu(self, menu):
-        """
-        affect a menu to self
-        Parameters
-        ----------
-        menu: (QtWidgets.QMenu)
-
-        """
-        self._menu = menu
-
-    def set_action_text(self, action_name, text: str):
-        self.get_action(action_name).setText(text)
-
-    def get_action(self, name):
-        if self.has_action(name):
-            return self._actions[name]
-        else:
-            raise KeyError(f'The action with name: {name} is not referenced'
-                           f' in the view actions: {self._actions.keys()}')
-
-    def has_action(self, action_name):
-        return action_name in self._actions
-
-    @property
-    def toolbar(self):
-        return self._toolbar
-
-    @property
-    def menu(self):
-        return self._menu
-
-    def affect_to(self, action_name, obj):
-        if isinstance(obj, QtWidgets.QToolBar) or isinstance(obj, QtWidgets.QMenu):
-            obj.addAction(self._actions[action_name])
-
-    def connect_action(self, name, slot, connect=True):
-        """
-        Connect (or disconnect) the action referenced by name to the given slot
-        Parameters
-        ----------
-        name: (str) key of the action as referenced in the self._actions dict
-        slot: (method) a method/function
-        connect: (bool) if True connect the trigegr signal of the action to the defined slot else disconnect it
-        """
-        if name in self._actions:
-            if connect:
-                self._actions[name].triggered.connect(slot)
-            else:
-                try:
-                    self._actions[name].triggered.disconnect()
-                except (TypeError,) as e:
-                    pass  # the action was not connected
-        else:
-            raise KeyError(f'The action with name: {name} is not referenced'
-                           f' in the view actions: {self._actions.keys()}')
-
-    @dispatch(str)
-    def is_action_visible(self, action_name: str):
-        if action_name in self._actions:
-            return self._actions[action_name].isVisible()
-        else:
-            raise KeyError(f'The action with name: {action_name} is not referenced'
-                           f' in the actions list: {self._actions}')
-
-    @dispatch(list)
-    def is_action_visible(self, actions_name: list):
-        isvisible = False
-        for action_name in actions_name:
-            isvisible = isvisible and self.is_action_visible(action_name)
-        return isvisible
-
-    @dispatch(str)
-    def is_action_checked(self, action_name: str):
-        if action_name in self._actions:
-            return self._actions[action_name].isChecked()
-        else:
-            raise KeyError(f'The action with name: {action_name} is not referenced'
-                           f' in the actions list: {self._actions}')
-
-    @dispatch(list)
-    def is_action_checked(self, actions_name: list):
-        ischecked = False
-        for action_name in actions_name:
-            ischecked = ischecked and self.is_action_checked(action_name)
-        return ischecked
-
-    @dispatch(str, bool)
-    def set_action_visible(self, action_name: str, visible=True):
-        if action_name in self._actions:
-            self._actions[action_name].setVisible(visible)
-        else:
-            raise KeyError(f'The action with name: {action_name} is not referenced'
-                           f' in the actions list: {self._actions}')
-
-    @dispatch(list, bool)
-    def set_action_visible(self, actions_name: list, visible=True):
-        for action_name in actions_name:
-            self.set_action_visible(action_name, visible)
-
-    @dispatch(str, bool)
-    def set_action_checked(self, action_name: str, checked=True):
-        if action_name in self._actions:
-            self._actions[action_name].setChecked(checked)
-        else:
-            raise KeyError(f'The action with name: {action_name} is not referenced'
-                           f' in the actions list: {self._actions}')
-
-    @dispatch(list, bool)
-    def set_action_checked(self, actions_name: list, checked=True):
-        for action_name in actions_name:
-            self.set_action_checked(action_name, checked)

pymodaq/daq_utils/managers/parameter_manager.py

@@ -1,57 +0,0 @@
-from pyqtgraph.parametertree import Parameter, ParameterTree
-
-
-class ParameterManager:
-    params = []
-
-    def __init__(self):
-        self.settings = Parameter.create(name='settings', type='group', children=self.params)  # create a Parameter
-        # object containing the settings defined in the preamble
-        # # create a settings tree to be shown eventually in a dock
-        self.settings_tree = ParameterTree()
-        self.settings_tree.setParameters(self.settings, showTop=False)  # load the tree with this parameter object
-        self.settings.sigTreeStateChanged.connect(self.parameter_tree_changed)
-
-    def parameter_tree_changed(self, param, changes):
-        for param, change, data in changes:
-            if change == 'childAdded':
-                self.child_added(param)
-
-            elif change == 'value':
-                self.value_changed(param)
-
-            elif change == 'parent':
-                self.param_deleted(param)
-
-    def value_changed(self, param):
-        """Non mandatory method  to be subclassed for actions to perform when one of the param's value in self.settings is changed
-
-        For instance:
-        if param.name() == 'do_something':
-            if param.value():
-                print('Do something')
-                self.settings.child('main_settings', 'something_done').setValue(False)
-
-        Parameters
-        ----------
-        param: (Parameter) the parameter whose value just changed
-        """
-        pass
-
-    def child_added(self, param):
-        """Non mandatory method to be subclassed for actions to perform when a param  has been added in self.settings
-
-        Parameters
-        ----------
-        param: (Parameter) the parameter that has been deleted
-        """
-        pass
-
-    def param_deleted(self, param):
-        """Non mandatory method to be subclassed for actions to perform when one of the param in self.settings has been deleted
-
-        Parameters
-        ----------
-        param: (Parameter) the parameter that has been deleted
-        """
-        pass