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

pymodaq/daq_utils/array_manipulation.py

@@ -1,386 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Mon March 03 2021
-author: Sebastien Weber
-"""
-import numpy as np
-
-
-def random_step(start, stop, step):
-    tmp = start
-    out = np.array([tmp])
-    sign = stop - start
-    if step == 0:
-        raise ValueError('step must be strictly positive or negative')
-    if step > 0 and sign > 0:
-        while tmp <= stop:
-            tmp = tmp + (np.random.random() + 0.5) * step
-            out = np.append(out, tmp)
-    elif step < 0 and sign < 0:
-        while tmp >= stop:
-            tmp = tmp + (np.random.random() + 0.5) * step
-            out = np.append(out, tmp)
-    else:
-        raise ValueError(f'the step value {step} is not of the same sign as stop - start : {sign}')
-    return out[0:-1]
-
-
-def linspace_this_vect(x, y=None, Npts=None):
-    """
-        Given a vector x, it returns a vector xlin where xlin is a
-        linearised version of x on the same interval and with the same size.
-        if args is provided it is a y vector and the function returns both xlin
-        and ylin where ylin is a linear interpolation of y on this new xlin axis
-    
-        Parameters
-        ----------
-        x : (ndarray)
-        y : (ndarray) optional
-        Npts: (int) size of the linear vector (optional)
-
-        Returns
-        -------
-        xlin : vector
-        (ylin : vector) optional if args is provided
-
-    """
-    if not Npts:
-        Npts = np.size(x)
-    xlin = np.linspace(np.min(x), np.max(x), Npts)
-    if y is not None:
-        ylin = np.interp(xlin, x, y)
-        return xlin, ylin
-    else:
-        return xlin
-
-    
-def find_index(x, threshold):
-    """
-    find_index finds the index ix such that x(ix) is the closest from threshold
-    
-    Parameters
-    ----------
-    x : vector
-    threshold : list of scalar
-
-    Returns
-    -------
-    out : list of 2-tuple containing ix,x[ix]
-            out=[(ix0,xval0),(ix1,xval1),...]
-    """
-
-    if np.isscalar(threshold):
-        threshold = [threshold]
-    out = []
-    for value in threshold:
-        ix = int(np.argmin(np.abs(x - value)))
-        out.append((ix, x[ix]))
-    return out
-
-
-def find_rising_edges(x, threshold):
-    """find_rising_edges finds the index ix such that x(ix) is the closest from threshold and values are increasing
-    
-    Parameters
-    ----------
-    x : vector
-    threshold : list of scalar
-
-    Returns
-    -------
-    out : list of 2-tuple containing ix,x[ix]
-            out=[(ix0,xval0),(ix1,xval1),...]
-    
-    """
-    x_shifted = np.concatenate((x[1:], np.array((np.NaN,))))
-    if np.isscalar(threshold):
-        threshold = [threshold]
-    out = []
-    for value in threshold:
-        dat = np.bitwise_and(x < value, x_shifted > value)
-        ix = [ind for ind, flag in enumerate(dat) if flag]
-        out.append((ix, x[ix]))
-    return out
-
-
-def crop_vector_to_axis(x, V, xlim):
-    """crops a vector V with given x axis vector to a given xlim tuple
-    
-    Parameters
-    ----------
-    x : vector
-    V : vector
-    xlim: tuple containing (xmin,xmax)
-    
-    Returns
-    -------
-    x_c : vector
-    V_c : vector
-    """
-    x1 = find_index(x, xlim[0])[0][0]
-    x2 = find_index(x, xlim[1])[0][0]
-    if x2 > x1:
-        ixx = np.linspace(x1, x2, x2 - x1 + 1, dtype=int);
-    else:
-        ixx = np.linspace(x2, x1, x1 - x2 + 1, dtype=int);
-
-    x_c = x[ixx]
-    V_c = V[ixx]
-    return x_c, V_c
-
-def rescale(x, window=[0.0, 1.0]):
-    """ Rescales a numpy array to the range specified by ``window``.
-
-    Default is [0, 1].
-    """
-    maxx = np.max(x)
-    minx = np.min(x)
-    return (x - minx) / (maxx - minx) * (window[1] - window[0]) + window[0]
-
-
-def marginals(data, normalize=False, axes=None):
-    """ Calculates the marginals of the data array.
-
-    axes specifies the axes of the marginals, e.g., the axes on which the
-    sum is projected.
-
-    If axis is None a list of all marginals is returned.
-    """
-    if axes is None:
-        axes = range(data.ndim)
-    axes = list(axes)
-    full_axes = list(range(data.ndim))
-    m = []
-    for i in axes:
-        # for the marginal sum over all axes except the specified one
-        margin_axes = tuple(j for j in full_axes if j != i)
-        m.append(np.sum(data, axis=margin_axes))
-    if normalize:
-        m = [rescale(mx) for mx in m]
-    return tuple(m) if len(m) != 1 else m[0]
-
-
-def find(x, condition, n=1):
-    """ Return the index of the nth element that fulfills the condition.
-    """
-    search_n = 1
-    for i in range(len(x)):
-        if condition(x[i]):
-            if search_n == n:
-                return i
-            search_n += 1
-    return -1
-
-
-def arglimit(y, threshold=1e-3, padding=0.0, normalize=True):
-    """ Returns the first and last index where `y >= threshold * max(abs(y))`.
-    """
-    t = np.abs(y)
-    if normalize:
-        t = t / np.max(t)
-
-    idx1 = find(t, lambda x: x >= threshold)
-    if idx1 == -1:
-        idx1 = 0
-    idx2 = find(t[::-1], lambda x: x >= threshold)
-    if idx2 == -1:
-        idx2 = t.shape[0] - 1
-    else:
-        idx2 = t.shape[0] - 1 - idx2
-
-    return (idx1, idx2)
-
-
-def limit(x, y=None, threshold=1e-3, padding=0.25, extend=True):
-    """ Returns the maximum x-range where the y-values are sufficiently large.
-
-    Parameters
-    ----------
-    x : array_like
-        The x values of the graph.
-    y : array_like, optional
-        The y values of the graph. If `None` the maximum range of `x` is
-        used. That is only useful if `padding > 0`.
-    threshold : float
-        The threshold relative to the maximum of `y` of values that should be
-        included in the bracket.
-    padding : float
-        The relative padding on each side in fractions of the bracket size.
-    extend : bool, optional
-        Signals if the returned range can be larger than the values in ``x``.
-        Default is `True`.
-
-    Returns
-    -------
-    xl, xr : float
-        Lowest and biggest value of the range.
-
-    """
-    if y is None:
-        x1, x2 = np.min(x), np.max(x)
-        if not extend:
-            return (x1, x2)
-    else:
-        idx1, idx2 = arglimit(y, threshold=threshold)
-        x1, x2 = sorted([x[idx1], x[idx2]])
-
-    # calculate the padding
-    if padding != 0.0:
-        pad = (x2 - x1) * padding
-        x1 -= pad
-        x2 += pad
-
-    if not extend:
-        x1 = max(x1, np.min(x))
-        x2 = min(x2, np.max(x))
-
-    return (x1, x2)
-
-
-def crop_array_to_axis(x, y, M, cropbox):
-    """crops an array M with given cropbox as a tuple (xmin,xmax,ymin,ymax).
-    
-    Parameters
-    ----------
-    x : vector
-    y : vector
-    M : 2D array
-    cropbox: 4 elements tuple containing (xmin,xmax,ymin,ymax)
-    
-    Returns
-    -------
-    x_c : croped x vector
-    y_c : croped y  vector
-    M_c : croped 2D M array
-
-    """
-    x1 = find_index(x, cropbox[0])[0][0]
-    x2 = find_index(x, cropbox[1])[0][0]
-    if x2 > x1:
-        ixx = np.linspace(x1, x2, x2 - x1 + 1, dtype=int)
-    else:
-        ixx = np.linspace(x2, x1, x1 - x2 + 1, dtype=int)
-
-    y1 = find_index(y, cropbox[2])[0][0]
-    y2 = find_index(y, cropbox[3])[0][0]
-    if y2 > y1:
-        iyy = np.linspace(y1, y2, y2 - y1 + 1, dtype=int)
-    else:
-        iyy = np.linspace(y2, y1, y1 - y2 + 1, dtype=int)
-
-    x_c = x[ixx]
-    y_c = y[iyy]
-
-    M_c = M[iyy[0]:iyy[-1] + 1, ixx[0]:ixx[-1] + 1]
-    return x_c, y_c, M_c
-
-
-def interp1D(x, M, xlin, axis=1):
-    """
-    same as numpy interp function but works on 2D array
-    you have to specify the axis over which to do the interpolation
-    kwargs refers to the numpy interp kwargs
-    returns both xlin and the new 2D array Minterp
-    """
-    if axis == 0:
-        Minterp = np.zeros((np.size(xlin), np.size(M, axis=1)))
-        indexes = np.arange(0, np.size(M, axis=1))
-        for ind in indexes:
-            #             print(ind)
-            Minterp[:, ind] = np.interp(xlin, x, M[:, ind])
-    else:
-        Minterp = np.zeros((np.size(M, axis=0), np.size(xlin)))
-        indexes = np.arange(0, np.size(M, axis=0))
-        for ind in indexes:
-            Minterp[ind, :] = np.interp(xlin, x, M[ind, :])
-    return Minterp
-
-
-def linspace_this_image(x, M, axis=1, Npts=None):
-    """
-    Given a vector x and a 2D array M, it returns an array vector xlin where xlin is a
-    linearised version of x on the same interval and with the same size. it returns as well
-    a 2D array Minterp interpolated on the new xlin vector along the specified axis.
-
-    Parameters
-    ----------
-    x : (vector)
-    M : (2D array)
-    axis : (int)
-    Npts: (int) size of the linear vector (optional)
-
-    Returns
-    -------
-    xlin : vector
-    Minterp : 2D array
-    """
-    xlin = linspace_this_vect(x, Npts=Npts)
-    Minterp = interp1D(x, M, xlin, axis=axis)
-
-    return xlin, Minterp
-
-
-def max_ind(x, axis=None):
-    """returns the max value in a vector or array and its index (in a tuple)
-
-    Parameters
-    ----------
-    x : vector
-    
-    axis : optional dimension aginst which to normalise
-      
-    Returns
-    -------
-    ind_max : index of the maximum value
-    
-    max_val : maximum value
-    """
-    ind_max = np.argmax(x, axis=axis)
-    max_val = np.max(x, axis=axis)
-    return ind_max, max_val
-
-
-def min_ind(x, axis=None):
-    """returns the min value in a vector or array and its index (in flattened array)
-
-    Parameters
-    ----------
-    x : vector
-    axis : optional dimension to check the function
-
-    Returns
-    -------
-    ind_min : index of the minimum value
-    min_val : minimum value
-    """
-    ind_min = np.argmin(x, axis=axis)
-    min_val = np.min(x, axis=axis)
-    return ind_min, min_val
-
-
-if __name__ == '__main__':                                          # pragma: no cover
-    from pymodaq.daq_utils import daq_utils as utils
-    import matplotlib.pyplot as plt
-
-    x = random_step(00, 100, 5)
-    y = random_step(00, 100, 5)
-    g2 = utils.gauss2D(x, 35, 15, y, 55, 20, 1)
-    (xlin, g2_interp) = linspace_this_image(x, g2, axis=1, Npts=100)
-    (ylin, g2_interp_both) = linspace_this_image(y, g2_interp, axis=0, Npts=100)
-    plt.figure('gauss2D')
-    plt.subplot(221)
-    plt.pcolormesh(x, y, g2)
-    plt.subplot(222)
-    plt.pcolormesh(xlin, y, g2_interp)
-    plt.subplot(223)
-    plt.pcolormesh(xlin, ylin, g2_interp_both)
-
-    plt.show()
-
-    x_c, y_c, M_c = crop_array_to_axis(x, y, g2, [20, 60, 40, 80])
-    plt.figure('cropped')
-    plt.subplot(121)
-    plt.pcolormesh(x, y, g2)
-    plt.subplot(122)
-    plt.pcolormesh(x_c, y_c, M_c)
-    plt.show()

pymodaq/daq_utils/config.py

@@ -1,273 +0,0 @@
-import datetime
-from pathlib import Path
-import toml
-from qtpy.QtCore import QObject
-from pymodaq.daq_utils.messenger import messagebox
-from pyqtgraph.parametertree import Parameter, ParameterTree
-from qtpy import QtWidgets, QtCore
-
-
-def getitem_recursive(dic, *args):
-    args = list(args)
-    while len(args) > 0:
-        dic = dic[args.pop(0)]
-    return dic
-
-
-def get_set_local_dir(basename='pymodaq_local'):
-    """Defines, creates abd returns a local folder where configurations files will be saved
-
-    Parameters
-    ----------
-    basename: (str) how the configuration folder will be named
-
-    Returns
-    -------
-    Path: the local path
-    """
-    local_path = Path.home().joinpath(basename)
-
-    if not local_path.is_dir():                            # pragma: no cover
-        try:
-            local_path.mkdir()
-        except Exception as e:
-            local_path = Path(__file__).parent.parent.joinpath(basename)
-            info = f"Cannot create local folder from your **Home** defined location: {Path.home()}," \
-                   f" using PyMoDAQ's folder as local directory: {local_path}"
-            print(info)
-            if not local_path.is_dir():
-                local_path.mkdir()
-    return local_path
-
-
-def get_set_config_path(config_name='config'):
-    """Creates a folder in the local config directory to store specific configuration files
-
-    Parameters
-    ----------
-    config_name: (str) name of the configuration folder
-
-    Returns
-    -------
-
-    See Also
-    --------
-    get_set_local_dir
-    """
-    local_path = get_set_local_dir()
-    path = local_path.joinpath(config_name)
-    if not path.is_dir():
-        path.mkdir()  # pragma: no cover
-    return path
-
-
-def get_set_log_path():
-    """ creates and return the config folder path for log files
-    """
-    return get_set_config_path('log')
-
-
-def get_set_preset_path():
-    """ creates and return the config folder path for managers files
-    """
-    return get_set_config_path('preset_configs')
-
-
-def get_set_batch_path():
-    """ creates and return the config folder path for managers files
-    """
-    return get_set_config_path('batch_configs')
-
-
-def get_set_pid_path():
-    """ creates and return the config folder path for PID files
-    """
-    return get_set_config_path('pid_configs')
-
-
-def get_set_layout_path():
-    """ creates and return the config folder path for layout files
-    """
-    return get_set_config_path('layout_configs')
-
-
-def get_set_remote_path():
-    """ creates and return the config folder path for remote (shortcuts or joystick) files
-    """
-    return get_set_config_path('remote_configs')
-
-
-def get_set_overshoot_path():
-    """ creates and return the config folder path for overshoot files
-    """
-    return get_set_config_path('overshoot_configs')
-
-
-def get_set_roi_path():
-    """ creates and return the config folder path for managers files
-    """
-    return get_set_config_path('roi_configs')
-
-
-def load_config(config_path=None, config_base_path=None):
-    if not config_path:
-        config_path = get_set_local_dir().joinpath('config.toml')
-    if not config_base_path:
-        config_base = toml.load(Path(__file__).parent.parent.joinpath('resources/config_template.toml'))
-    else:
-        config_base = toml.load(config_base_path)
-    if not config_path.exists():  # copy the template from pymodaq folder and create one in pymodad's local folder
-        config_path.write_text(toml.dumps(config_base))
-
-    # check if all fields are there
-    config = toml.load(config_path)
-    if check_config(config_base, config):
-        config_path.write_text(toml.dumps(config))
-        config = config_base
-    return config
-
-
-class ConfigError(Exception):
-    pass
-
-
-class Config:
-    def __init__(self, config_path=None, config_base_path=None):
-        self._config = load_config(config_path, config_base_path)
-        self.config_path = config_path
-        self.config_base_path = config_base_path
-
-    def __call__(self, *args):
-        try:
-            ret = getitem_recursive(self._config, *args)
-        except KeyError as e:
-            raise ConfigError(f'the path {args} does not exist in your configuration toml file, check '
-                              f'your pymodaq_local folder')
-        return ret
-
-    def to_dict(self):
-        return self._config
-
-    def __getitem__(self, item):
-        """for backcompatibility when it was a dictionnary"""
-        return self._config[item]
-
-
-def set_config(config_as_dict, config_path=None):
-    if not config_path:
-        config_path = get_set_local_dir().joinpath('config.toml')
-
-    config_path.write_text(toml.dumps(config_as_dict))
-
-
-def check_config(config_base, config_local):
-    status = False
-    for key in config_base:
-        if key in config_local:
-            if isinstance(config_base[key], dict):
-                status = status or check_config(config_base[key], config_local[key])
-        else:
-            config_local[key] = config_base[key]
-            status = True
-    return status
-
-
-class TreeFromToml(QObject):
-    def __init__(self, config=None, conf_path=None, config_base_path=None):
-        super().__init__()
-        if config is None:
-            if conf_path is None:
-                config_path = get_set_local_dir().joinpath('config.toml')
-            else:
-                config_path = conf_path
-            config = Config(config_path, config_base_path)
-        self.config_path = config_path
-        params = [{'title': 'Config path', 'name': 'config_path', 'type': 'str', 'value': str(config.config_path),
-                   'readonly': True}]
-        params.extend(self.dict_to_param(config.to_dict()))
-
-        self.settings = Parameter.create(title='settings', name='settings', type='group', children=params)
-        self.settings_tree = ParameterTree()
-        self.settings_tree.setParameters(self.settings, showTop=False)
-
-    def show_dialog(self):
-
-        self.dialog = QtWidgets.QDialog()
-        self.dialog.setWindowTitle('Please enter new configuration values!')
-        self.dialog.setLayout(QtWidgets.QVBoxLayout())
-        buttonBox = QtWidgets.QDialogButtonBox(parent=self.dialog)
-
-        buttonBox.addButton('Save', buttonBox.AcceptRole)
-        buttonBox.accepted.connect(self.dialog.accept)
-        buttonBox.addButton('Cancel', buttonBox.RejectRole)
-        buttonBox.rejected.connect(self.dialog.reject)
-
-        self.dialog.layout().addWidget(self.settings_tree)
-        self.dialog.layout().addWidget(buttonBox)
-        self.dialog.setWindowTitle('Configuration entries')
-        res = self.dialog.exec()
-
-        if res == self.dialog.Accepted:
-            with open(self.config_path, 'w') as f:
-                config = self.param_to_dict(self.settings)
-                config.pop('config_path')
-                toml.dump(config, f)
-
-    @classmethod
-    def param_to_dict(cls, param):
-        config = dict()
-        for child in param.children():
-            if 'group' in child.opts['type']:
-                config[child.name()] = cls.param_to_dict(child)
-            else:
-                if child.opts['type'] == 'datetime':
-                    config[child.name()] = datetime.fromtimestamp(
-                        child.value().toSecsSinceEpoch())  # convert QDateTime to python datetime
-                elif child.opts['type'] == 'date':
-                    qdt = QtCore.QDateTime()
-                    qdt.setDate(child.value())
-                    pdt = datetime.fromtimestamp(qdt.toSecsSinceEpoch())
-                    config[child.name()] = pdt.date()
-                elif child.opts['type'] == 'list':
-                    config[child.name()] = child.opts['limits']
-                else:
-                    config[child.name()] = child.value()
-        return config
-
-    @classmethod
-    def dict_to_param(cls, config):
-        params = []
-        for key in config:
-            if isinstance(config[key], dict):
-                params.append({'title': f'{key.capitalize()}:', 'name': key, 'type': 'group',
-                               'children': cls.dict_to_param(config[key]),
-                               'expanded': 'user' in key.lower() or 'general' in key.lower()})
-            else:
-                param = {'title': f'{key.capitalize()}:', 'name': key, 'value': config[key]}
-                if isinstance(config[key], float):
-                    param['type'] = 'float'
-                elif isinstance(config[key], bool):  # placed before int because a bool is an instance of int
-                    param['type'] = 'bool'
-                elif isinstance(config[key], int):
-                    param['type'] = 'int'
-                elif isinstance(config[key], datetime.datetime):
-                    param['type'] = 'datetime'
-                elif isinstance(config[key], datetime.date):
-                    param['type'] = 'date'
-                elif isinstance(config[key], str):
-                    param['type'] = 'str'
-                elif isinstance(config[key], list):
-                    param['type'] = 'list'
-                    param['values'] = config[key]
-                    param['value'] = config[key][0]
-                    param['show_pb'] = True
-                params.append(param)
-        return params
-
-    
-if __name__ == '__main__':
-    config = load_config()
-    config = Config()
-    config('style', 'darkstyle')
-    assert config('style', 'darkstyle') == config['style']['darkstyle']
-

pymodaq/daq_utils/conftests.py

@@ -1,7 +0,0 @@
-
-qtbotskip = False
-
-main_modules_skip = True
-
-
-

pymodaq/daq_utils/custom_parameter_tree.py

@@ -1,9 +0,0 @@
-from .daq_utils import set_logger
-from .parameter.ioxml import *
-from .parameter.pymodaq_ptypes import *
-from .parameter.utils import *
-
-logger = set_logger('custom_paramater', add_to_console=True)
-logger.warning('Calling the custom_parameter_module will soon be deprecated!\n'
-               'Please use either the ioxml, utils or pymodaq_ptypes submodules from the '
-               'pymodaq.daq_utils.parameter module')