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

autooptions/_tests/test_qtutil.py

@@ -0,0 +1,245 @@
+import pyperclip
+from qtpy.QtWidgets import QWidget
+from qtpy.QtGui import QKeyEvent
+from qtpy.QtCore import QEvent
+from qtpy.QtCore import Qt
+from autooptions.qtutil import WidgetTool
+from autooptions.qtutil import TableView
+from autooptions.qtutil import PlotWidget
+
+
+
+COUNTER_TEXT_CHANGED = 0
+
+
+
+class ParentWidget(QWidget):
+
+
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Test")
+
+
+
+def handleTextChanged(text):
+    global COUNTER_TEXT_CHANGED
+    COUNTER_TEXT_CHANGED = COUNTER_TEXT_CHANGED + 1
+
+
+def testGetLineInput(make_napari_viewer_proxy):
+    make_napari_viewer_proxy()
+    parent = ParentWidget()
+    label, inputWidget = WidgetTool.getLineInput(parent,
+                                            "your guess",
+                                            10,
+                                            50,
+                                            handleTextChanged)
+    assert label in parent.children()
+    assert inputWidget in parent.children()
+    assert label.parent() == parent
+    assert inputWidget.parent() == parent
+    assert label.text() == "your guess"
+    counter = COUNTER_TEXT_CHANGED
+    assert inputWidget.text() == str(10)
+    inputWidget.setText("20")
+    assert COUNTER_TEXT_CHANGED == counter  # Only editing in the interface sends the signal,
+                                            # not programmatically changing the value
+    assert inputWidget.maximumWidth() == 50
+
+
+def testGetLineInputNoCallback(make_napari_viewer_proxy):
+    make_napari_viewer_proxy()
+    parent = ParentWidget()
+    label, inputWidget = WidgetTool.getLineInput(parent,
+                                            "your guess",
+                                            10,
+                                            50,
+                                            None)
+    assert label in parent.children()
+    assert inputWidget in parent.children()
+    assert label.parent() == parent
+    assert inputWidget.parent() == parent
+    assert label.text() == "your guess"
+    counter = COUNTER_TEXT_CHANGED
+    assert inputWidget.text() == str(10)
+    inputWidget.setText("20")
+    assert inputWidget.maximumWidth() == 50
+    assert COUNTER_TEXT_CHANGED == counter
+
+
+def testGetComboBox(make_napari_viewer_proxy, mocker):
+    make_napari_viewer_proxy()
+    parent = ParentWidget()
+    callback = mocker.stub(name='onSelectedFruitChanged')
+    label, comboWidget = WidgetTool.getComboInput(parent,
+                                                  "fruits",
+                                                  ["apple", "orange", "banana"],
+                                                  callback=callback)
+    assert label in parent.children()
+    assert comboWidget in parent.children()
+    assert label.parent() == parent
+    assert comboWidget.parent() == parent
+    assert label.text() == "fruits"
+    allItems = [comboWidget.itemText(i) for i in range(comboWidget.count())]
+    assert allItems == ["apple", "orange", "banana"]
+    assert comboWidget.currentText() == "apple"
+    comboWidget.setCurrentText("banana")
+    assert comboWidget.currentText() == "banana"
+    callback.assert_called_once_with("banana")
+
+
+def testReplaceItemsInComboBox(make_napari_viewer_proxy, mocker):
+    make_napari_viewer_proxy()
+    parent = ParentWidget()
+    label, comboWidget = WidgetTool.getComboInput(parent,
+                                                  "fruits",
+                                                  ["apple", "orange", "banana"])
+    WidgetTool.replaceItemsInComboBox(comboWidget, ["lemon", "ananas"])
+    allItems = [comboWidget.itemText(i) for i in range(comboWidget.count())]
+    assert allItems == ["lemon", "ananas"]
+    assert comboWidget.currentText() == "lemon"
+    comboWidget.setCurrentIndex(1)
+    WidgetTool.replaceItemsInComboBox(comboWidget, ["apple", "ananas"])
+    allItems = [comboWidget.itemText(i) for i in range(comboWidget.count())]
+    assert allItems == ["apple", "ananas"]
+    assert comboWidget.currentText() == "ananas"
+
+
+def testGetCheckBox(make_napari_viewer_proxy, mocker):
+    make_napari_viewer_proxy()
+    parent = ParentWidget()
+    callback = mocker.stub(name='onRemoveBackgroundChanged')
+    label, checkbox = WidgetTool.getCheckbox(parent,
+                                             "remove background",
+                                             True,
+                                             50,
+                                             callback)
+    assert label in parent.children()
+    assert checkbox in parent.children()
+    assert checkbox.parent() == parent
+    assert label.parent() == parent
+    assert label.text() == "remove background"
+    assert checkbox.isChecked()
+    assert checkbox.maximumWidth() == 50
+    checkbox.setChecked(False)
+    callback.assert_called_once_with(False)
+    label2, checkbox2 = WidgetTool.getCheckbox(parent,
+                                             "smooth",
+                                             False,
+                                             50,
+                                             None)
+    assert not checkbox2.isChecked()
+
+
+
+class TestTableView:
+
+
+    def testConstructor(self, make_napari_viewer_proxy):
+        make_napari_viewer_proxy()
+        table = {"area": [23.87, 65.28, 12.98], "mean": [19992, 2233, 24553]}
+        tableView = TableView(table)
+        assert tableView.data == table
+        tableView2 = TableView(None)
+        assert not tableView2.data
+
+
+    def testSetData(self, make_napari_viewer_proxy):
+        make_napari_viewer_proxy()
+        table = {"area": [23.87, 65.28, 12.98], "mean": [19992, 2233, 24553]}
+        table2 = {"fruits": ["apple", "orange", "banana"], "animals": ["lion", "tiger"]}
+        tableView = TableView(table)
+        tableView.setData(table2)
+        assert tableView.data == table2
+
+
+    def testResetView(self, make_napari_viewer_proxy):
+        make_napari_viewer_proxy()
+        table = {"area": [23.87, 65.28, 12.98], "mean": [19992, 2233, 24553]}
+        tableView = TableView(table)
+        tableView.resetView()
+        assert tableView.data == table
+
+
+    def testKeyPressEvent(self, make_napari_viewer_proxy):
+        pyperclip.copy("")
+        make_napari_viewer_proxy()
+        table = {"area": [23.87, 65.28, 12.98], "mean": [19992, 2233, 24553]}
+        tableView = TableView(table)
+        tableView.selectAll()
+        event = QKeyEvent(QEvent.Type.KeyPress, Qt.Key.Key_C, Qt.KeyboardModifier.ControlModifier, "copy")
+        tableView.keyPressEvent(event)
+        text = pyperclip.paste()
+        assert "23.87" in text
+        assert "24553" in text
+
+
+    def testKeyPressEventNoCopy(self, make_napari_viewer_proxy):
+        pyperclip.copy("")
+        make_napari_viewer_proxy()
+        table = {"area": [23.87, 65.28, 12.98], "mean": [19992, 2233, 24553]}
+        tableView = TableView(table)
+        tableView.selectAll()
+        event = QKeyEvent(QEvent.Type.KeyPress, Qt.Key.Key_C, Qt.KeyboardModifier.ShiftModifier, "copy")
+        tableView.keyPressEvent(event)
+        text = pyperclip.paste()
+        assert text == ""
+
+
+    def testCopyDataToClipboard(self, make_napari_viewer_proxy):
+        pyperclip.copy("")
+        make_napari_viewer_proxy()
+        table = {"area": [23.87, 65.28, 12.98], "mean": [19992, 2233, 24553]}
+        tableView = TableView(table)
+        tableView.copyDataToClipboard()
+        text = pyperclip.paste()
+        assert text == ""
+        tableView.selectAll()
+        tableView.copyDataToClipboard()
+        text = pyperclip.paste()
+        assert "23.87" in text
+        assert "24553" in text
+
+
+class TestPlotWidget:
+
+
+    def testConstructor(self, make_napari_viewer_proxy):
+        viewer = make_napari_viewer_proxy()
+        plot = PlotWidget(viewer)
+        assert plot.figure
+        assert plot.X == []
+        assert plot.Y == []
+
+
+    def testAddData(self, make_napari_viewer_proxy):
+        viewer = make_napari_viewer_proxy()
+        plot = PlotWidget(viewer)
+        plot.addData([1, 2, 3], [1, 4, 9], "r+")
+        assert [1, 2, 3] in plot.X
+        assert [1, 4, 9] in plot.Y
+        assert "r+" in plot.formatStrings
+
+
+    def testClearData(self, make_napari_viewer_proxy):
+        viewer = make_napari_viewer_proxy()
+        plot = PlotWidget(viewer)
+        plot.addData([1, 2, 3], [1, 4, 9], "r+")
+        plot.clear()
+        assert True
+
+
+    def testDisplay(self, make_napari_viewer_proxy):
+        viewer = make_napari_viewer_proxy()
+        plot = PlotWidget(viewer)
+        plot.addData([1, 2, 3], [1, 4, 9], "r+")
+        plot.display()
+        assert plot.ax.get_xlabel() == plot.xLabel
+        assert plot.ax.get_ylabel() == plot.yLabel
+        plot2 = PlotWidget(viewer)
+        plot2.addData([1, 2, 3], [1, 4, 9])
+        plot2.display()
+        assert plot2.ax.get_xlabel() == plot2.xLabel
+        assert plot2.ax.get_ylabel() == plot2.yLabel
+

autooptions/_tests/test_widget.py

@@ -0,0 +1,132 @@
+import pytest
+import os
+import numpy as np
+from autooptions.widget import OptionsWidget
+from autooptions.options import Options
+
+class FakeEvent:
+    modifiers = {}
+
+
+class TestOptionsWidget:
+
+
+
+    def onSomethingHappened(self, value):
+        self.lastValue = value
+
+
+    @pytest.fixture()
+    def options(self):
+        options = Options("Autooptions Test", "Widget Test")
+        options.addImage('image', value=None, transient=True)
+        options.addLabels('labels', value='labels_layer', transient=True)
+        options.addPoints('points', value='points_layer', transient=True)
+        options.addFFT('fft', value=None, transient=True)
+        options.addStr("group", value="lps")
+        options.addInt('size xy', value=3)
+        options.addInt('size z', value=1)
+        options.addChoice('footprint', choices=["none", "cube", "ball", "octahedron"], callback=self.onSomethingHappened)
+        options.addFloat('sigma', value=1.34)
+        options.addBool('do it', value=True)
+        yield options
+
+
+    def testConstructor(self, options, make_napari_viewer_proxy):
+        viewer = make_napari_viewer_proxy()
+        widget = OptionsWidget(viewer, options, self)
+        assert widget.options is options
+        assert widget.viewer is viewer
+        assert widget.client is self
+
+
+    def testAddApplyButton(self, options, make_napari_viewer_proxy, mocker):
+        viewer = make_napari_viewer_proxy()
+        widget = OptionsWidget(viewer, options, self)
+        assert widget.getApplyButton() is None
+        callback = mocker.stub(name='onApplyButtonPressed')
+        widget.addApplyButton(callback)
+        assert not widget.getApplyButton() is None
+        assert callback.call_count == 0
+
+
+    def testAddOKButton(self, options, make_napari_viewer_proxy, mocker):
+        viewer = make_napari_viewer_proxy()
+        widget = OptionsWidget(viewer, options, self)
+        assert widget.getOKButton() is None
+        callback = mocker.stub(name='onOKButtonPressed')
+        widget.addOKButton(callback)
+        assert not widget.getOKButton() is None
+        assert callback.call_count == 0
+
+
+    def testAddCancelButton(self, options, make_napari_viewer_proxy, mocker):
+        viewer = make_napari_viewer_proxy()
+        widget = OptionsWidget(viewer, options, self)
+        assert widget.getCancelButton() is None
+        callback = mocker.stub(name='onCancelButtonPressed')
+        widget.addCancelButton(callback)
+        assert not widget.getCancelButton() is None
+        assert callback.call_count == 0
+
+
+    def test_OnApplyButtonClicked(self, options, make_napari_viewer_proxy, mocker):
+        viewer = make_napari_viewer_proxy()
+        widget = OptionsWidget(viewer, options, self)
+        callback = mocker.stub(name='self.apply')
+        widget.addApplyButton(callback)
+        options.setValue('group', 'xps')
+        if os.path.exists(options.optionsPath):
+            os.remove(options.optionsPath)
+        widget._onApplyButtonClicked()
+        assert os.path.exists(options.optionsPath)
+        assert options.value("group") == "lps"
+
+
+    def test_OnOKButtonClicked(self, options, make_napari_viewer_proxy, mocker):
+        viewer = make_napari_viewer_proxy()
+        widget = OptionsWidget(viewer, options, self)
+        callback = mocker.stub(name='self.ok')
+        widget.addOKButton(callback)
+        viewer.window.add_dock_widget(widget, name=options.optionsName)
+        options.setValue('group', 'xps')
+        if os.path.exists(options.optionsPath):
+            os.remove(options.optionsPath)
+        widget._onOKButtonClicked()
+        assert os.path.exists(options.optionsPath)
+        assert options.value("group") == "lps"
+
+
+    def test_OnCancelButtonClicked(self, options, make_napari_viewer_proxy, mocker):
+        viewer = make_napari_viewer_proxy()
+        widget = OptionsWidget(viewer, options, self)
+        callback = mocker.stub(name='self.cancel')
+        widget.addCancelButton(callback)
+        viewer.window.add_dock_widget(widget, name=options.optionsName)
+        options.setValue('group', 'xps')
+        if os.path.exists(options.optionsPath):
+            os.remove(options.optionsPath)
+        widget._onCancelButtonClicked()
+        assert not os.path.exists(options.optionsPath)
+        assert options.value("group") == "xps"
+
+
+    def test_OnLayerAddedOrRemoved(self, options, make_napari_viewer_proxy):
+        viewer = make_napari_viewer_proxy()
+        widget = OptionsWidget(viewer, options, self)
+        viewer.window.add_dock_widget(widget, name=options.optionsName)
+        data = np.random.rand(12, 12)
+        viewer.add_image(data=data, name='data')
+        assert True
+
+
+    def testGetImageLayer(self, options, make_napari_viewer_proxy):
+        viewer = make_napari_viewer_proxy()
+        widget = OptionsWidget(viewer, options, self)
+        viewer.window.add_dock_widget(widget, name=options.optionsName)
+        data = np.random.rand(12, 12)
+        viewer.add_image(data=data, name='labels_layer')
+        layer = widget.getImageLayer("labels")
+        assert layer is not None
+        assert layer.name == "labels_layer"
+        assert layer.data.shape == (12, 12)

autooptions/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.4'
+__version_tuple__ = version_tuple = (0, 1, 4)
+
+__commit_id__ = commit_id = None

autooptions/array_util.py

@@ -0,0 +1,39 @@
+import numpy as np
+
+
+
+class ArrayUtil:
+    """A class to provide utils that do common operations on arrays.
+    """
+
+
+    @staticmethod
+    def stripZeroRowsAndColumns(data, zero=0):
+        """Return an array with all-zero rows and columns removed.
+
+        Returns a stripped array, with all rows and columns, in which each
+        element is zero, removed. Instead of rows and comumns with all zero
+        elements, rows and columns containing another number, string or
+        object at each position can be removed from the array.
+
+        :param data:  A table from which empty rows and columns will be stripped
+        :type data: numpy.ndarray
+        :param zero: The element for which rows and columns will be removed
+        :return: A 3-tupel with
+
+            * the input array data with all-zero rows and columns removed
+            * A 1D array of the indices of the columns that are not all zero
+              in the input array
+            * A 1D array of the indices of the rows that are not all zero
+              in the input array
+
+        :rtype: (numpy.ndarray, numpy.ndarray, numpy.ndarray)
+        """
+        rowIndices = np.where(~np.all(data == zero, axis=1))[0]
+        stripped = data[~np.all(data == zero, axis=1)]
+        stripped = np.array(list(zip(*stripped)))
+        columnIndices = np.where(~np.all(stripped == zero, axis=1))[0]
+        stripped = stripped[~np.all(stripped == zero, axis=1)]
+        stripped = np.array(list(zip(*stripped)))
+        return stripped, columnIndices, rowIndices
+

autooptions/napari_util.py

@@ -0,0 +1,133 @@
+from napari.layers.labels.labels import Labels
+from napari.layers.points.points import Points
+from napari.layers.image.image import Image
+
+
+
+class NapariUtil:
+    """ Utility methods for the napari image viewer.
+    """
+
+    def __init__(self, viewer):
+        """ Constructor.
+
+        :param viewer: the napari viewer
+        :type viewer: napari.viewer.Viewer
+        """
+        self.viewer = viewer
+
+
+    def getImageLayers(self):
+        """ Return all image layers
+
+                :return: A list of the image layers in the viewer
+                :rtype: [napari.layers.image.Image.Image]
+                """
+        return self.getLayersOfType(Image)
+
+
+    def getFFTLayers(self):
+        """ Return all fft layers
+
+                        :return: A list of the fft layers in the viewer
+                        :rtype: [napari.layers.image.Image.Image]
+                        """
+        imageLayers = self.getImageLayers()
+        imageLayers = [self.getLayerWithName(name) for name in imageLayers]
+        fftLayers = [layer.name for layer in imageLayers if 'fft' in layer.metadata.keys()]
+        return fftLayers
+
+
+    def getLabelLayers(self):
+        """ Return all label layers
+
+        :return: A list of the label layers in the viewer
+        :rtype: [napari.layers.labels.labels.Labels]
+        """
+        return self.getLayersOfType(Labels)
+
+
+    def getPointsLayers(self):
+        """ Return all point layers
+
+        :return: A list of the point layers in the viewer
+        :rtype: [napari.layers.points.points.Points]
+        """
+        return self.getLayersOfType(Points)
+
+
+    def getLayersOfType(self, layerType):
+        """ Return all layers of type layerType in the viewer
+
+        :param layerType: A napari layer type like Labels or Points.
+        :return: A list of the layers with the given type
+        """
+        layers = [layer.name for layer in self.viewer.layers if isinstance(layer, layerType)]
+        return layers
+
+
+    def getDataOfLayerWithName(self, name):
+        """ Return the data of the layer with the given name.
+
+        :param name: The name of the layer
+        :type name: str
+        :return: The layer with the given name if it exists and None otherwise
+        """
+        layer = self.getLayerWithName(name)
+        if layer:
+            return layer.data
+        else:
+            return None
+
+
+    def getLayerWithName(self, name):
+        """ Answer the layer with the given name, if it exists and None otherwise.
+
+        :param name: The name of a layer
+        :return: The layer from napari's layer list that has the given name
+        """
+        for layer in self.viewer.layers:
+            if layer.name == name:
+                return layer
+        return None
+
+
+    def getDataAndScaleOfLayerWithName(self, name):
+        """ Answer the data, the scale and the unit of the layer with the given name.
+
+        :param name: The name of a layer
+        :return: A tupel with the data, the scale and the unit of the layer with the given name.
+                 The unit is the unit of the first dimension. The unit is supposed to be the same for all dimensions.
+        """
+        layer = self.getLayerWithName(name)
+        return layer.data, layer.scale, str(layer.units[0])
+
+
+    @staticmethod
+    def getOriginalPath(layer):
+        """ Answer the source path of the layer if it represents an image opened from the filesystem and the
+        original path from the metadata if it is a derived image. If it is neither an image opened from a file nor
+        derived from one (for example an image programmatically created) answer None. For the metadata information to
+        be present, the image operations must set it.
+
+        :param layer: The input layer
+        :return: The path of the image in the filesystem if it is known
+        """
+        if 'original_path' in layer.metadata.keys():
+            return layer.metadata['original_path']
+        if layer.source.path:
+            return layer.source.path
+        return None
+
+
+    @staticmethod
+    def copyOriginalPath(srcLayer, destLayer):
+        """Copy the orignal path from one layer to another. This should be used by operations that create images derived
+        from an input image.
+
+        :param srcLayer: The layer from which the original path is copied.
+        :param destLayer: The layer to which the original path is copied.
+        """
+        path = NapariUtil.getOriginalPath(srcLayer)
+        destLayer.metadata['original_path'] = path
+