pymodaq 4.4.7__py3-none-any.whl → 5.0.1__py3-none-any.whl

pymodaq/utils/parameter/pymodaq_ptypes/list.py

@@ -1,150 +0,0 @@
-from qtpy import QtWidgets, QtGui, QtCore
-from pyqtgraph.parametertree.parameterTypes.list import ListParameter, ListParameterItem
-from pyqtgraph.parametertree.Parameter import ParameterItem
-
-
-class Combo_pb(QtWidgets.QWidget):
-
-    def __init__(self, items=[]):
-        super(Combo_pb, self).__init__()
-        self.items = items
-        self.initUI()
-        self.count = self.combo.count
-
-    def initUI(self):
-        """
-            Init the User Interface.
-        """
-        self.hor_layout = QtWidgets.QHBoxLayout()
-        self.combo = QtWidgets.QComboBox()
-        self.combo.addItems(self.items)
-        self.add_pb = QtWidgets.QPushButton()
-        self.add_pb.setText("")
-        icon3 = QtGui.QIcon()
-        icon3.addPixmap(QtGui.QPixmap(":/icons/Icon_Library/Add2.png"), QtGui.QIcon.Normal, QtGui.QIcon.Off)
-        self.add_pb.setIcon(icon3)
-        self.hor_layout.addWidget(self.combo)
-        self.hor_layout.addWidget(self.add_pb)
-        self.hor_layout.setSpacing(0)
-        self.hor_layout.setContentsMargins(0, 0, 0, 0)
-        self.add_pb.setMaximumWidth(25)
-        self.setLayout(self.hor_layout)
-        self.currentText = self.combo.currentText
-        self.setCurrentIndex = self.combo.setCurrentIndex
-        self.clear = self.combo.clear
-        self.addItem = self.combo.addItem
-        self.findText = self.combo.findText
-
-
-class ListParameterItem(ListParameterItem):
-    """
-        WidgetParameterItem subclass providing comboBox that lets the user select from a list of options.
-
-    """
-
-    def __init__(self, param, depth):
-        super().__init__(param, depth)
-
-    def makeWidget(self):
-        """
-            Make a widget from self parameter options, connected to the buttonClicked function.
-
-            Returns
-            -------
-            w:widget
-                the initialized widget
-
-            See Also
-            --------
-            buttonClicked, limitsChanged,
-        """
-        opts = self.param.opts
-        t = opts['type']
-        w = Combo_pb()
-        w.add_pb.clicked.connect(self.buttonClicked)
-        w.setMaximumHeight(20)  # # set to match height of spin box and line edit
-        if 'show_pb' in opts:
-            w.add_pb.setVisible(opts['show_pb'])
-        else:
-            w.add_pb.setVisible(False)
-        w.sigChanged = w.combo.currentIndexChanged
-        w.value = self.value
-        w.setValue = self.setValue
-        self.widget = w  # # needs to be set before limits are changed
-        self.limitsChanged(self.param, self.param.opts['limits'])
-        if len(self.forward) > 0:
-            self.setValue(self.param.value())
-        return w
-
-    def buttonClicked(self):
-        """
-            |
-            | Append the self limits attributes an added parameter with string value.
-            | Update parameter and call the limitschanged method to map the added parameter.
-
-            See Also
-            --------
-            limitsChanged,
-        """
-        if isinstance(self.param.opts['limits'], list):
-            text, ok = QtWidgets.QInputDialog.getText(None, "Enter a value to add to the parameter",
-                                                      "String value:", QtWidgets.QLineEdit.Normal)
-            if ok and not (text == ""):
-                self.param.opts['limits'].append(text)
-                self.limitsChanged(self.param, self.param.opts['limits'])
-                self.param.setValue(text)
-        elif isinstance(self.param.opts['limits'], dict):
-            text, ok = QtWidgets.QInputDialog.getText(None, "Enter a text to add to the parameter",
-                                                      "String value:", QtWidgets.QLineEdit.Normal)
-            if ok and not (text == ""):
-
-                value, ok = QtWidgets.QInputDialog.getInt(None, "Enter an integer value to add to the parameter",
-                                                          "integer value:", QtWidgets.QLineEdit.Normal)
-                if ok:
-                    self.param.opts['limits'].update({text: value})
-                    self.limitsChanged(self.param, self.param.opts['limits'])
-                    self.param.setValue(text)
-
-    def optsChanged(self, param, opts):
-        """
-            Called when any options are changed that are not name, value, default, or limits.
-
-            =============== ================================== =======================================
-            **Parameters**    **Type**                           **Description**
-            *param*           instance of pyqtgraph parameter    The parameter to be checked
-            *opts*            string list                        The option dictionnary to be checked
-            =============== ================================== =======================================
-
-            See Also
-            --------
-            optsChanged
-        """
-        super().optsChanged(param, opts)
-        if 'show_pb' in opts:
-            self.widget.add_pb.setVisible(opts['show_pb'])
-        if 'enabled' in opts:
-            self.widget.setEnabled(opts['enabled'])
-
-
-class ListParameter(ListParameter):
-    """
-        =============== =======================================
-        **Attributes**    **Type**
-        *itemClass*       instance of ListParameterItem_custom
-        *sigActivated*    instance of pyqt Signal
-        =============== =======================================
-    """
-    itemClass = ListParameterItem
-    sigActivated = QtCore.Signal(object)
-
-    def __init__(self, **opts):
-        super().__init__(**opts)
-
-    def activate(self):
-        """
-            Emit the Activated signal.
-        """
-        self.sigActivated.emit(self)
-        self.emitStateChanged('activated', None)
-
-

pymodaq/utils/parameter/pymodaq_ptypes/numeric.py

@@ -1,18 +0,0 @@
-from pyqtgraph.parametertree.parameterTypes.basetypes import SimpleParameter
-from pyqtgraph.parametertree.parameterTypes.numeric import NumericParameterItem
-
-
-class NumericParameter(SimpleParameter):
-    itemClass = NumericParameterItem
-
-    def __init__(self, **opts):
-        super().__init__(**opts)
-
-    def setLimits(self, limits):
-        curVal = self.value()
-        if curVal > limits[1]:
-            self.setValue(limits[1])
-        elif curVal < limits[0]:
-            self.setValue(limits[0])
-        super().setLimits(limits)
-        return limits

pymodaq/utils/parameter/pymodaq_ptypes/pixmap.py

@@ -1,175 +0,0 @@
-import numpy as np
-from qtpy import QtWidgets, QtGui
-from qtpy.QtCore import QByteArray, QObject
-from pyqtgraph.parametertree.parameterTypes.basetypes import WidgetParameterItem, SimpleParameter
-from qtpy import QtWidgets, QtGui
-from qtpy.QtCore import QByteArray
-from pyqtgraph.parametertree.parameterTypes.basetypes import WidgetParameterItem
-
-
-class PixmapCheckData:
-    def __init__(self, data: np.ndarray, path: str = '', checked: bool = False, info: str = ''):
-        if data is not None:
-            data = data / np.max(data) * 255
-            data = data.astype(np.uint8)
-            self.data = data[:, :]
-        else:
-            self.data = []
-        self.path = path
-        self.checked = checked
-        self.info = info
-
-    def __eq__(self, other):
-        if other is None:
-            return False
-        else:
-            status = np.all(np.isclose(self.data, other.data))
-            status = status and self.checked == other.checked
-            status = status and self.path == other.path
-            return status
-
-
-class PixmapCheckWidget(QtWidgets.QWidget):
-    """ value of this parameter is a PixmapCheckData
-
-    See Also
-    --------
-    PixmapCheckedData
-    """
-
-    def __init__(self):
-
-        super().__init__()
-        self._data: PixmapCheckData = None
-        self.checkbox: QtWidgets.QCheckBox = None
-        self.label: QtWidgets.QLabel = None
-        self.info_label: QtWidgets.QLabel = None
-        self.initUI()
-
-    def initUI(self):
-        """
-            Init the User Interface.
-        """
-        self.setLayout(QtWidgets.QHBoxLayout())
-        self.layout().setContentsMargins(0, 0, 0, 0)
-        self.label = QtWidgets.QLabel()
-        self.label.setMaximumWidth(100)
-        self.label.setMinimumHeight(50)
-        self.label.setMaximumHeight(50)
-        self.layout().addWidget(self.label)
-
-        ver_widget = QtWidgets.QWidget()
-        ver_widget.setLayout(QtWidgets.QVBoxLayout())
-        self.checkbox = QtWidgets.QCheckBox('Show/Hide')
-        self.info_label = QtWidgets.QLabel()
-        # self.info.setReadOnly(True)
-        self.checkbox.setChecked(False)
-        ver_widget.layout().addWidget(self.info_label)
-        ver_widget.layout().addWidget(self.checkbox)
-        ver_widget.layout().setSpacing(0)
-        ver_widget.layout().setContentsMargins(0, 0, 0, 0)
-        self.layout().addWidget(ver_widget)
-
-    def setValue(self, data: PixmapCheckData):
-
-
-        im = QtGui.QImage(data.data, *data.data.shape, QtGui.QImage.Format_Indexed8)
-        a = QtGui.QPixmap.fromImage(im)
-
-        self.label.setPixmap(a)
-        self.checkbox.setChecked(data.checked)
-        self.info_label.setText(data.info)
-        self._data = data
-
-    def value(self):
-        return PixmapCheckData(data=self._data.data if self._data is not None else None,
-                               checked=self.checkbox.isChecked(),
-                               info=self._data.info if self._data is not None else '',
-                               path=self._data.path if self._data is not None else '')
-
-
-class PixmapParameterItem(WidgetParameterItem):
-    """Registered parameter type which displays a QPixmap in a QLabel"""
-
-    def makeWidget(self):
-        w = QtWidgets.QLabel()
-        w.sigChanged = None
-        w.value = w.pixmap
-        w.setValue = w.setPixmap
-        return w
-
-
-class PixmapCheckParameterItem(WidgetParameterItem):
-    """Registered parameter type which displays a PixmapCheckWidget custom widget"""
-
-    def makeWidget(self):
-        w = PixmapCheckWidget()
-        w.sigChanged = w.checkbox.clicked
-        w.value = w.value
-        w.setValue = w.setValue
-        self.hideWidget = False
-        return w
-
-
-class PixmapCheckParameter(SimpleParameter):
-    itemClass = PixmapCheckParameterItem
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-
-class PixmapParameter(SimpleParameter):
-    itemClass = PixmapParameterItem
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-
-
-def main_widget():
-    import sys
-    app = QtWidgets.QApplication(sys.argv)
-    prog = PixmapCheckWidget()
-    prog.show()
-    data = np.arange(128 * 256).reshape((256, 128))
-    data = data / np.max(data) * 255
-    data = data.astype(np.uint8)
-    prog.setValue(PixmapCheckData(data=data,
-                                  checked=True,
-                                  info='this is an info'))
-
-    def print_toggled(status):
-        print(f"toggled: {status}")
-
-    prog.checkbox.toggled.connect(print_toggled)
-
-    sys.exit(app.exec_())
-
-
-def main_parameter():
-    from pymodaq.utils.managers.parameter_manager import ParameterManager
-    data = np.arange(128 * 256).reshape((256, 128))
-    data = data / np.max(data) * 255
-    data = data.astype(np.uint8)
-
-    class PixmapParameter(ParameterManager):
-        params = {'title': 'Overlays', 'name': 'overlays', 'type': 'group', 'children': [
-            {'name': f'Overlay{0:03.0f}', 'type': 'pixmap_check',
-             'value': PixmapCheckData(data=data, checked=False,
-                                      info=f'This is an info')},
-            {'name': 'other', 'type': 'bool_push', 'value': True},
-            {'name': 'otherp', 'type': 'led_push', 'value': True},
-        ]},
-
-        def value_changed(self, param):
-            print(f'Value changed for {param}: {param.value()}')
-
-    import sys
-    app = QtWidgets.QApplication(sys.argv)
-    prog = PixmapParameter()
-    prog.settings_tree.show()
-
-    sys.exit(app.exec_())
-
-
-if __name__ == '__main__':
-    main_parameter()

pymodaq/utils/parameter/pymodaq_ptypes/slide.py

@@ -1,166 +0,0 @@
-from qtpy import QtWidgets, QtCore
-from pyqtgraph.widgets.SpinBox import SpinBox
-from pyqtgraph.parametertree.parameterTypes.basetypes import WidgetParameterItem, SimpleParameter
-from pymodaq.utils.parameter.utils import scroll_log, scroll_linear
-import numpy as np
-
-
-class SliderSpinBox(QtWidgets.QWidget):
-
-    def __init__(self, *args, subtype='lin', **kwargs):
-
-        super().__init__()
-        self.subtype = subtype
-        self.initUI(*args, **kwargs)
-
-        self.valueChanged = self.spinbox.valueChanged  # (value)  for compatibility with QSpinBox
-        self.sigValueChanged = self.spinbox.sigValueChanged  # (self)
-        self.sigValueChanging = self.spinbox.sigValueChanging  # (self, value)  sent immediately; no delay.
-        self.sigChanged = self.spinbox.sigValueChanged
-
-    @property
-    def opts(self):
-        return self.spinbox.opts
-
-    @opts.setter
-    def opts(self, **opts):
-        self.setOpts(**opts)
-
-    def setOpts(self, **opts):
-        self.spinbox.setOpts(**opts)
-        if 'visible' in opts:
-            self.slider.setVisible(opts['visible'])
-
-    def insert_widget(self ,widget, row=0):
-        self.vlayout.insertWidget(row, widget)
-
-    def initUI(self, *args, **kwargs):
-        """
-            Init the User Interface.
-        """
-        self.vlayout = QtWidgets.QVBoxLayout()
-        self.slider = QtWidgets.QSlider(QtCore.Qt.Horizontal)
-        self.slider.setMinimumWidth(50)
-        self.slider.setMinimum(0)
-        self.slider.setMaximum(100)
-        if 'value' in kwargs:
-            value = kwargs.pop('value')
-        else:
-            if 'bounds' in kwargs:
-                value = kwargs['bounds'][0]
-            else:
-                value = 1
-        if value is None:
-            value = 0                
-        self.spinbox = SpinBox(parent=None, value=value, **kwargs)
-
-        self.vlayout.addWidget(self.slider)
-        self.vlayout.addWidget(self.spinbox)
-        self.vlayout.setSpacing(0)
-        self.vlayout.setContentsMargins(0, 0, 0, 0)
-        self.setLayout(self.vlayout)
-
-        self.slider.valueChanged.connect(self.update_spinbox)
-        self.spinbox.valueChanged.connect(self.update_slide)
-        self.spinbox.valueChanged.emit(value) #Initializing slider from value
-
-    def get_bounds(self,):
-        """ Convert bounds from opts into list of floats
-
-        Returns:
-            list of floats
-        """
-        return [float(bound) for bound in self.opts['bounds']]
-
-    def update_spinbox(self, val):
-        """
-        val is a percentage [0-100] used in order to set the spinbox value between its min and max
-        """
-        min_val,max_val = self.get_bounds()
-        if self.subtype == 'log':
-            val_out = scroll_log(val, min_val, max_val)
-        else:
-            val_out = scroll_linear(val, min_val, max_val)
-        try:
-            self.slider.valueChanged.disconnect(self.update_spinbox)
-            self.spinbox.valueChanged.disconnect(self.update_slide)
-        except Exception:
-            pass
-        self.spinbox.setValue(val_out)
-
-        self.slider.valueChanged.connect(self.update_spinbox)
-        self.spinbox.valueChanged.connect(self.update_slide)
-
-    def update_slide(self, val):
-        """
-        val is the spinbox value between its min and max
-        """
-        min_val,max_val = self.get_bounds()
-        try:
-            self.slider.valueChanged.disconnect(self.update_spinbox)
-            self.spinbox.valueChanged.disconnect(self.update_slide)
-        except Exception:
-            pass
-        if self.subtype == 'linear':
-            value = int((val - min_val) / (max_val - min_val) * 100)
-        else:
-            value = int((np.log10(val) - np.log10(min_val)) / (np.log10(max_val) - np.log10(min_val)) * 100)
-        self.slider.setValue(value)
-        self.slider.valueChanged.connect(self.update_spinbox)
-        self.spinbox.valueChanged.connect(self.update_slide)
-
-    def setValue(self, val):
-        self.spinbox.setValue(val)
-
-    def value(self):
-        return self.spinbox.value()
-    
-
-class SliderParameterItem(WidgetParameterItem):
-    """Registered parameter type which displays a QLineEdit"""
-
-    def makeWidget(self):
-        opts = self.param.opts
-        defs = {
-            'value': 0, 'min': None, 'max': None,
-             'dec': False,
-            'siPrefix': False, 'suffix': '', 'decimals': 12,
-            'int': False
-        }
-        #Update relevant opts
-        for k in defs:
-            if k in opts:
-                defs[k] = opts[k]    
-        #Additional changes according to user syntax
-        if 'subtype' not in opts:
-            opts['subtype'] = 'linear'
-        defs['bounds'] = [0., float(self.param.value() or 1)]  # max value set to default value when no max given or 1 if no default
-        if 'limits' not in opts:
-            if 'min' in opts:
-                defs['bounds'][0] = opts['min']
-            if 'max' in opts:
-                defs['bounds'][1] = opts['max']
-        else:
-            defs['bounds'] = opts['limits']
-                                
-        w = SliderSpinBox(subtype=opts['subtype'],**defs)
-        self.setSizeHint(1, QtCore.QSize(50, 50))
-        return w
-
-    def updateDisplayLabel(self, value=None):
-        # Reimplement display label to show the spinbox text with its suffix
-        if value is None:
-            value = self.widget.spinbox.text()
-        super().updateDisplayLabel(value)    
-
-    def showEditor(self):
-        # Reimplement show Editor to specifically select the numbers
-        super().showEditor()
-        self.widget.spinbox.setFocus()     
-
-
-class SliderParameter(SimpleParameter):
-    itemClass = SliderParameterItem
-
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)

pymodaq/utils/parameter/pymodaq_ptypes/table.py

@@ -1,135 +0,0 @@
-from qtpy import QtWidgets, QtCore
-from collections import OrderedDict
-from pyqtgraph.parametertree.parameterTypes.basetypes import WidgetParameterItem
-from pyqtgraph.parametertree import Parameter
-
-
-class TableWidget(QtWidgets.QTableWidget):
-    """
-        ============== ===========================
-        *Attributes**    **Type**
-        *valuechanged*   instance of pyqt Signal
-        *QtWidgets*      instance of QTableWidget
-        ============== ===========================
-    """
-
-    valuechanged = QtCore.Signal(OrderedDict)
-
-    def __init__(self):
-        super().__init__()
-
-    def get_table_value(self):
-        """
-            Get the contents of the self coursed table.
-
-            Returns
-            -------
-            data : ordered dictionnary
-                The getted values dictionnary.
-        """
-        data = OrderedDict([])
-        for ind in range(self.rowCount()):
-            item0 = self.item(ind, 0)
-            item1 = self.item(ind, 1)
-            if item0 is not None and item1 is not None:
-                try:
-                    data[item0.text()] = float(item1.text())
-                except Exception:
-                    data[item0.text()] = item1.text()
-        return data
-
-    def set_table_value(self, data_dict):
-        """
-            Set the data values dictionnary to the custom table.
-
-            =============== ====================== ================================================
-            **Parameters**    **Type**               **Description**
-            *data_dict*       ordered dictionnary    the contents to be stored in the custom table
-            =============== ====================== ================================================
-        """
-        try:
-            self.setRowCount(len(data_dict))
-            self.setColumnCount(2)
-            for ind, (key, value) in enumerate(data_dict.items()):
-                item0 = QtWidgets.QTableWidgetItem(key)
-                item0.setFlags(item0.flags() ^ QtCore.Qt.ItemIsEditable)
-                if isinstance(value, float):
-                    item1 = QtWidgets.QTableWidgetItem('{:.3e}'.format(value))
-                else:
-                    item1 = QtWidgets.QTableWidgetItem(str(value))
-                item1.setFlags(item1.flags() ^ QtCore.Qt.ItemIsEditable)
-                self.setItem(ind, 0, item0)
-                self.setItem(ind, 1, item1)
-            # self.valuechanged.emit(data_dict)
-
-        except Exception as e:
-            pass
-
-
-class TableParameterItem(WidgetParameterItem):
-
-    # def treeWidgetChanged(self):
-    #     """
-    #         Check for changement in the Widget tree.
-    #     """
-    #     # # TODO: fix so that superclass method can be called
-    #     # # (WidgetParameter should just natively support this style)
-    #     # WidgetParameterItem.treeWidgetChanged(self)
-    #     self.treeWidget().setFirstItemColumnSpanned(self.subItem, True)
-    #     self.treeWidget().setItemWidget(self.subItem, 0, self.widget)
-    #
-    #     # for now, these are copied from ParameterItem.treeWidgetChanged
-    #     self.setHidden(not self.param.opts.get('visible', True))
-    #     self.setExpanded(self.param.opts.get('expanded', True))
-
-    def makeWidget(self):
-        """
-            Make and initialize an instance of TableWidget.
-
-            Returns
-            -------
-            table : instance of TableWidget.
-                The initialized table.
-
-            See Also
-            --------
-            TableWidget
-        """
-        self.asSubItem = True
-        self.hideWidget = False
-        opts = self.param.opts
-        w = TableWidget()
-        if 'tip' in opts:
-            w.setToolTip(opts['tip'])
-        w.setColumnCount(2)
-        if 'header' in opts:
-            w.setHorizontalHeaderLabels(self.param.opts['header'])
-        if 'height' not in opts:
-            opts['height'] = 200
-        w.setMaximumHeight(opts['height'])
-        w.horizontalHeader().setSectionResizeMode(QtWidgets.QHeaderView.Stretch)
-        # self.table.setReadOnly(self.param.opts.get('readonly', False))
-        w.value = w.get_table_value
-        w.setValue = w.set_table_value
-        w.sigChanged = w.itemChanged
-        return w
-
-
-class TableParameter(Parameter):
-    """
-        =============== =================================
-        **Attributes**    **Type**
-        *itemClass*       instance of TableParameterItem
-        *Parameter*       instance of pyqtgraph parameter
-        =============== =================================
-    """
-    itemClass = TableParameterItem
-    """Editable string; displayed as large text box in the tree."""
-
-    # def __init(self):
-    #     super(TableParameter,self).__init__()
-
-    def setValue(self, value):
-        self.opts['value'] = value
-        self.sigValueChanged.emit(self, value)
-