auto-options-python 0.1.4__py3-none-any.whl

autooptions/options.py

@@ -0,0 +1,311 @@
+import os
+import appdirs
+import json
+from copy import copy
+
+
+
+class Options:
+    """ Options are a list of parameters that are intended to be passed to an operation. Options have
+    a name, a type and a value.
+    """
+
+
+    def __init__(self, applicationName, optionsName):
+        """
+        Construct an empty Options object for an operation within an application.
+
+        The options will be saved into a file optionsName in the subfolder applicationName of the user-data-folder.
+        Spaces in the names will be replaced by underscores in the folder and filename.
+
+        :param applicationName: The name of the application
+        :param optionsName: The name of the options
+        """
+        self.optionsName = optionsName
+        self.applicationName = applicationName
+        self.items = {}
+        self.defaultItems = None
+        appName = self.applicationName.replace(' ', '_')
+        self.dataFolder = appdirs.user_data_dir(appName)
+        os.makedirs(self.dataFolder, exist_ok=True)
+        optName = self.optionsName.replace(' ', '_')
+        self.optionsPath = os.path.join(self.dataFolder, optName + "_options.json")
+
+
+    def setDefaultValues(self, defaultItems):
+        """
+        Set the default values for all options in the options object. Currently unused. The idea is that it might be
+        useful to have default values, other than in the code, to which the option can be reset.
+
+        :param defaultItems: A dictionary of default values for all options in the options object.
+        """
+        self.defaultItems = defaultItems
+
+
+    def getItems(self):
+        """
+        Return the items stored in the options object.
+
+        :return: A dictionary of all options in the options object.
+        """
+        if not self.items and self.defaultItems:
+            self.items = copy(self.defaultItems)
+        return self.items
+
+
+    def save(self):
+        """
+        Save the options as a JSON file.
+        """
+        with open(self.optionsPath, 'w') as f:
+            json.dump(self.getItems(), f)
+
+
+    def load(self):
+        """
+        Load the options as a JSON file.
+        """
+        if not os.path.exists(self.optionsPath):
+            self.save()
+        with open(self.optionsPath) as f:
+            items = json.load(f)
+        for key, value in items.items():
+            if value['transient']:
+                continue
+            self.items[key] = value
+
+
+    def get(self, name):
+        """
+        Answer the option with the given name.
+
+        :param name: The name of an option
+        :return: Answers the option with the given name as a dictionary
+        """
+        return self.items[name]
+
+
+    def value(self, name):
+        """
+        Answer the value of the option with the given name.
+
+        :param name: The name of an option
+        :return: The value of the option with the given name. The type of the result depends on the type of the option.
+        """
+        return self.get(name)['value']
+
+
+    def set(self, name, option):
+        """
+        Set the option in options under the given name.
+
+        :param name: The name of an option
+        :param option: The new option
+        """
+        self.items[name] = option
+
+
+    def setValue(self, name, value):
+        """
+        Set the value of the option with the given name to value
+        :param name: The name of an option
+        :param value: The new value of the option
+        """
+        self.get(name)['value'] = value
+
+
+    @classmethod
+    def getCallbackName(cls, callback):
+        callbackName = None
+        if callback:
+            callbackName = callback.__name__
+        return callbackName
+
+
+    def addImage(self, name='image', value=None, transient=True, position=None, callback=None):
+        """
+        Add an option that represents the selection of an image. Image options are often transient.
+
+        :param name: The name of the image option
+        :param value: The value of the image option
+        :param transient: Whether the image option is transient. Transient options are not saved and reloaded.
+        :param position: The position of the image option within the options (Could be used when dictionaries are not
+                         ordered). If none is given, the next free position is used.
+        :param callback: The callback function, that is called when the value of the option is changed.
+        """
+        self.set(name, self.getBaseOption(value, transient, position, callback) | {
+                            'type': 'image'})
+
+
+    def addLabels(self, name='labels', value=None, transient=True, position=None, callback=None):
+        """
+        Add an option that represents the selection of a labels image. Labels options are often transient.
+
+        :param name: The name of the labels option
+        :param value: The value of the labels option
+        :param transient: Whether the labels option is transient. Transient options are not saved and reloaded.
+        :param position: The position of the labels option within the options (Could be used when dictionaries are not
+                         ordered). If none is given, the next free position is used.
+        :param callback: The callback function, that is called when the value of the option is changed.
+        """
+        self.set(name, self.getBaseOption(value, transient, position, callback) | {
+            'type': 'labels'})
+
+
+    def addFFT(self, name='fft', value=None, transient=True, position=None, callback=None):
+        """
+        Add an option that represents the selection of an FFT image. Image options are often transient. The FFT
+        is not a standard image, since only the amplitude information is in the image, while the phase information is
+        kept in the metadata.
+
+        :param name: The name of the option
+        :param value: The name of the fft layer
+        :param transient: Whether the fft option is transient. Transient options are not saved and reloaded.
+        :param position: The position of the fft option within the options. (Could be used when dictionaries are not
+                         ordered). If none is given, the next free position is used.
+        :param callback: A callback function, that is called when the selected fft layer changes
+        """
+        self.set(name, self.getBaseOption(value, transient, position, callback) | {
+                            'type': 'fft'})
+
+
+    def addPoints(self, name='points', value=None, transient=True, position=None, callback=None):
+        """
+        Add an option that represents the selection of a points layer. Points options are often transient.
+
+        :param name: The name of the points option
+        :param value: The value of the points option
+        :param transient: Whether the points option is transient. Transient options are not saved and reloaded.
+        :param position: The position of the points option within the options (Could be used when dictionaries are not
+                         ordered). If none is given, the next free position is used.
+        :param callback: The callback function, that is called when the value of the option is changed.
+        """
+        self.set(name, self.getBaseOption(value, transient, position, callback) | {
+            'type': 'points'})
+
+
+    def addInt(self, name, value=1, transient=False, position=None, widget="input", callback=None):
+        """
+        An option that represents an integer value.
+
+        :param name: The name of the option
+        :param value: The integer value
+        :param transient: Whether the option is transient. Transient options are not saved and reloaded.
+        :param position: The position of the option within the options. (Could be used when dictionaries are not
+                         ordered). If none is given, the next free position is used.
+        :param widget: Currently only the input-widget, which means entering the number into an input field, is
+                       implemented. However, an integer could also be entered in a different way, for example using
+                       a slider.
+        :param callback: A callback function, that is called when the value is changed via the graphical interface.
+        """
+        self.set(name, self.getBaseOption(value, transient, position, callback) | {
+                            'type': 'int',
+                            'widget': widget})
+
+
+    def addFloat(self, name, value=0.0, transient=False, position=None, widget="input", callback=None):
+        """
+        An option that represents a float value.
+
+        :param name:  The name of the option
+        :param value: The float value
+        :param transient: Whether the option is transient. Transient options are not saved and reloaded.
+        :param position: The position of the option within the options. (Could be used when dictionaries are not
+                         ordered). If none is given, the next free position is used.
+        :param widget: Currently only the input-widget, which means entering the number into an input field, is
+                       implemented. However, a float could also be entered in a different way, for example using
+                       a slider.
+        :param callback: A callback function, that is called when the value is changed via the graphical interface.
+        """
+        self.set(name, self.getBaseOption(value, transient, position, callback) | {
+                            'type': 'float',
+                            'widget': widget})
+
+
+    def addChoice(self, name, value=None, choices=None, transient=False, position=None, callback=None):
+        """
+        An option that represents a choice in a list of given values.
+
+        :param name: The name of the option
+        :param value: The text of the selected choice
+        :param choices: A collection of possible values
+        :param transient: Whether the option is transient. Transient options are not saved and reloaded.
+        :param position: The position of the option within the options. (Could be used when dictionaries are not
+                         ordered). If none is given, the next free position is used.
+        :param callback: A callback function, that is called whenever the selected item is changed, whether via the gui
+                         or programmatically. The implementer must take care to avoid endless loops.
+        """
+        if not choices:
+            choices = []
+        self.set(name, self.getBaseOption(value, transient, position, callback) | {
+            'type': 'choice',
+            'choices': choices})
+
+
+    def addStr(self, name, value="", transient=False, position=None, callback=None):
+        """
+        An option that represents a textual value.
+
+        :param name:  The name of the option
+        :param value: The text
+        :param transient: Whether the option is transient. Transient options are not saved and reloaded.
+        :param position: The position of the option within the options. (Could be used when dictionaries are not
+                         ordered). If none is given, the next free position is used.
+        :param callback: A callback function, that is called when the value is changed via the graphical interface.
+        """
+        self.set(name,
+                 self.getBaseOption(value, transient, position, callback) | {
+                     'type': 'str',
+                     'widget': "input"})
+
+
+    def addBool(self, name, value=False, transient=False, position=None, callback=None):
+        """
+        An option that represents a binary choice.
+
+        :param name: The name of the option
+        :param value: The boolean value, True or False
+        :param transient: Whether the option is transient. Transient options are not saved and reloaded.
+        :param position: The position of the option within the options. (Could be used when dictionaries are not
+                         ordered). If none is given, the next free position is used.
+        :param callback: A callback function, that is called whenever the selected item is changed, whether via the gui
+                         or programmatically. The implementer must take care to avoid endless loops.
+        """
+        self.set(name,
+                 self.getBaseOption(value, transient, position, callback) | {
+                     'type': 'bool',
+                     'widget': "checkbox"})
+
+
+    def getBaseOption(self, value, transient, position, callback):
+        """
+        A helper method to set the parts of an option that a common to all kinds of options.
+
+        :param value:  The value of the option
+        :param transient: Whether the option is transient. Transient options are not saved and reloaded.
+        :param position: The position of the option within the options. (Could be used when dictionaries are not
+                         ordered). If none is given, the next free position is used.
+        :param callback: A callback function, that is called when the value of the option changes.
+        """
+        option = {'value': value,
+                  'transient': transient,
+                  'position': self._getPosition(position),
+                  'callback': self.getCallbackName(callback)}
+        return option
+
+
+    def _getPosition(self, position):
+        """
+        If the position is None, the next free position is returned. The next free position is the
+        maximal position plus one. If position is not None, the given position is returned.
+
+        :param position: None or a non-negative integer
+        :return: A non-negative integer, which is either the given position or the next free position
+        """
+        if not position:
+            positions = [option["position"] for option in self.items.values()]
+            if positions:
+                position = max([option["position"] for option in self.items.values()]) + 1
+            else:
+                position = 1
+        return position

autooptions/qtutil.py

@@ -0,0 +1,270 @@
+from typing import TYPE_CHECKING
+import pyperclip
+import numpy as np
+import matplotlib.pyplot as plt
+from qtpy.QtWidgets import QHBoxLayout, QCheckBox
+from qtpy.QtCore import Qt
+from qtpy.QtWidgets import QWidget, QVBoxLayout, QHBoxLayout
+from qtpy.QtWidgets import QLabel, QLineEdit, QComboBox, QTableWidget, QTableWidgetItem, QAction
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
+from napari.utils import notifications
+from autooptions.array_util import ArrayUtil
+if TYPE_CHECKING:
+    import napari
+
+
+
+class WidgetTool:
+    """
+    Utility methods for working with qt-widgets.
+    """
+
+    @staticmethod
+    def getLineInput(parent, labelText, defaultValue, fieldWidth, callback):
+        """Returns a label displaying the given text and an input field
+        with the given default value.
+
+        :param parent: The parent widget of the label and the input field
+        :param labelText: The text of the label
+        :param defaultValue: The value initailly displayed in the input field
+        :param fieldWidth: The width of the input field
+        :param callback: A callback function with a parameter text. The function
+                         is called with the new text when the content of the
+                         input field changes
+        :return: A tupel of the label and the input field
+        :rtype: (QLabel, QLineEdit)
+        """
+        label = QLabel(parent)
+        label.setText(labelText)
+        inputWidget = QLineEdit(parent)
+        inputWidget.setText(str(defaultValue))
+        if callback:
+            inputWidget.textEdited.connect(callback)
+        inputWidget.setMaximumWidth(fieldWidth)
+        return label, inputWidget
+
+
+    @staticmethod
+    def getComboInput(parent, labelText, values, callback=None):
+        """Returns a label displaying the given text and a combo-box
+        with the given values.
+
+        :param parent: The parent widget of the label and the input field
+        :param labelText: The text of the label
+        :param values: The values in the list of the combo-box
+        :param callback: A callback function that is called with the new text when the selected text changes.
+        :return: A tupel of the label and the input field
+        :rtype: (QLabel, QComboBox)
+        """
+        label = QLabel(parent)
+        label.setText(labelText)
+        inputCombo = QComboBox(parent)
+        inputCombo.addItems(values)
+        if callback:
+            inputCombo.currentTextChanged.connect(callback)
+        return label, inputCombo
+
+
+    @staticmethod
+    def replaceItemsInComboBox(comboBox, newItems):
+        """Replace the items in the combo-box with newItems
+
+        :param comboBox: The combo-box in which the items will be replaced
+        :param newItems: The new items that will replace the current items
+                         in the combo-box.
+        """
+        selectedText = comboBox.currentText()
+        comboBox.clear()
+        comboBox.addItems(newItems)
+        index = -1
+        try:
+            index = newItems.index(selectedText)
+        except ValueError:
+            index = -1
+        if index > -1:
+            comboBox.setCurrentIndex(index)
+
+
+    @staticmethod
+    def getCheckbox(parent, labelText, defaultValue, fieldWidth, callback):
+        """Answers a label and a checkbox checked or unchecked depeding on the default value.
+
+        :param parent: The parent widget of the label and the input field
+        :param labelText: The text of the label
+        :param defaultValue: The boolean default value
+        :param fieldWidth: The maximum width of the checkbox
+        :param callback: A callback function
+        :return: A tupel of a label and a checkbox
+        """
+        label = QLabel(parent)
+        label.setText(labelText)
+        cb = QCheckBox(parent)
+        cb.setChecked(defaultValue)
+        if callback:
+            cb.stateChanged.connect(callback)
+        cb.setMaximumWidth(fieldWidth)
+        return label, cb
+
+
+
+class TableView(QTableWidget):
+    """ A table that allows to copy the selected cells to the system-clipboard.
+    """
+
+    def __init__(self, data, *args):
+        """Create a new table from data.
+
+        :param data: A dictionary with the column names as keys and the data
+        in the columns as lists.
+        """
+        rows = 0
+        columns = 0
+        if data:
+            columns = len(data)
+            rows = len(list(data.values())[0])
+        QTableWidget.__init__(self, rows, columns, *args)
+        self.data = data
+        if data:
+            self.__setData()
+        self.setContextMenuPolicy(Qt.ActionsContextMenu)
+        copyAction = QAction("Copy\tCtrl+C", self)
+        copyAction.triggered.connect(self.copyDataToClipboard)
+        self.addAction(copyAction)
+        self.resetAction = QAction("Reset", self)
+        self.addAction(self.resetAction)
+        self.deleteAction = QAction("Delete", self)
+        self.addAction(self.deleteAction)
+
+
+    def setData(self, table):
+        """Clear the table and replace the data in the table with the input table"""
+        self.data = table
+        self.resetView()
+
+
+    def resetView(self):
+        """Resets the view to the data of the table view"""
+        self.clear()
+        self.__setData()
+
+
+    def __setData(self):
+        horizontalHeaders = []
+        for n, key in enumerate(self.data.keys()):
+            horizontalHeaders.append(key)
+            for m, item in enumerate(self.data[key]):
+                newItem = QTableWidgetItem(str(item))
+                newItem.setTextAlignment(Qt.AlignRight)
+                self.setItem(m, n, newItem)
+        self.setHorizontalHeaderLabels(horizontalHeaders)
+        self.resizeColumnsToContents()
+        self.resizeRowsToContents()
+
+
+    def keyPressEvent(self, event):
+        """Copy the selected table data to the system clipboard if the key-event
+        is ctrl+C.
+
+        :param event: The received key-pressed event.
+        """
+        super().keyPressEvent(event)
+        if event.key() == Qt.Key_C and (event.modifiers() & Qt.ControlModifier):
+            self.copyDataToClipboard()
+
+
+    def copyDataToClipboard(self):
+        """ Copy the data in the selected table-cells into the system clipboard.
+        """
+        notifications.show_info("copying data to clipboard")
+        tableDataAsText = self.getSelectedDataAsString()
+        pyperclip.copy(tableDataAsText)
+
+
+    def getSelectedDataAsString(self):
+        """ Get the data in the selected cells as a string. Columns are
+        separated by tabs and lines by newlines".
+        """
+        copied_cells = self.selectedIndexes()
+        if len(copied_cells) == 0:
+            return ""
+        labels = [self.horizontalHeaderItem(id).text() for id in range(0, self.columnCount())]
+        data = [['' for i in range(self.columnCount())] for j in range(self.rowCount())]
+        for cell in copied_cells:
+            data[cell.row()][cell.column()] = cell.data()
+        table =  np.array(data)
+        table, columnIndices, _ = ArrayUtil.stripZeroRowsAndColumns(table, zero='')
+        lines = ''
+        for row in table:
+            lines = lines + "\t".join([str(elem) for elem in row]) + "\n"
+        lines = lines[:-1]
+        remainingHeadings = [labels[index] for index in columnIndices]
+        result = "\t".join(remainingHeadings) + "\n" + lines
+        return result
+
+
+
+class PlotWidget(QWidget):
+    """
+    A widget that contains a pyplot plot.
+    """
+
+    def __init__(self, viewer: "napari.viewer.Viewer"):
+        """Create a new empty plot widget.
+
+            param viewer: The napari viewer in which the widget will be displayed
+        """
+        super().__init__()
+        self.figure = plt.figure()
+        self.ax = self.figure.add_subplot(111)
+        self.canvas = FigureCanvas(self.figure)
+        self.viewer = viewer
+        self.createLayout()
+        self.formatStrings = []
+        self.title = "Plot"
+        self.X = []
+        self.Y = []
+        self.area = 'left'
+        self.tabify = True
+        self.xLabel = "x"
+        self.yLabel = "y"
+
+
+    def createLayout(self):
+        """Create the layout of the widget.
+        """
+        mainLayout = QVBoxLayout()
+        canvasLayout = QHBoxLayout()
+        canvasLayout.addWidget(self.canvas)
+        mainLayout.addLayout(canvasLayout)
+        self.setLayout(mainLayout)
+
+
+    def addData(self, X, Y, formatString=None):
+        """Add the data and the format string.
+        """
+        self.X.append(X)
+        self.Y.append(Y)
+        if formatString:
+            self.formatStrings.append(formatString)
+
+
+    def clear(self):
+        """Remove everything from the plot.
+        """
+        self.figure.clear()
+
+
+    def display(self):
+        """Display the plot as a dock widget in napari.
+        """
+        self.ax.set_xlabel(self.xLabel)
+        self.ax.set_ylabel(self.yLabel)
+        if self.formatStrings:
+            for x, y, plotFormat in zip(self.X, self.Y, self.formatStrings):
+                self.ax.plot(x, y, plotFormat)
+        else:
+            for x, y in zip(self.X, self.Y):
+                self.ax.plot(x, y)
+        self.canvas.draw()
+        self.viewer.window.add_dock_widget(self, area=self.area, name=self.title, tabify=self.tabify)
+