bec-widgets 0.54.0__py3-none-any.whl → 0.56.0__py3-none-any.whl

tests/unit_tests/test_spiral_progress_bar.py

@@ -0,0 +1,338 @@
+# pylint: disable=missing-function-docstring, missing-module-docstring, unused-import
+
+import pytest
+from bec_lib.endpoints import MessageEndpoints
+from pydantic import ValidationError
+
+from bec_widgets.utils import Colors
+from bec_widgets.widgets import SpiralProgressBar
+from bec_widgets.widgets.spiral_progress_bar.ring import RingConfig, RingConnections
+from bec_widgets.widgets.spiral_progress_bar.spiral_progress_bar import SpiralProgressBarConfig
+
+from .client_mocks import mocked_client
+
+
+@pytest.fixture
+def spiral_progress_bar(qtbot, mocked_client):
+    widget = SpiralProgressBar(client=mocked_client)
+    qtbot.addWidget(widget)
+    qtbot.waitExposed(widget)
+    yield widget
+    widget.close()
+
+
+def test_bar_init(spiral_progress_bar):
+    assert spiral_progress_bar is not None
+    assert spiral_progress_bar.client is not None
+    assert isinstance(spiral_progress_bar, SpiralProgressBar)
+    assert spiral_progress_bar.config.widget_class == "SpiralProgressBar"
+    assert spiral_progress_bar.config.gui_id is not None
+    assert spiral_progress_bar.gui_id == spiral_progress_bar.config.gui_id
+
+
+def test_config_validation_num_of_bars():
+    config = SpiralProgressBarConfig(num_bars=100, min_num_bars=1, max_num_bars=10)
+
+    assert config.num_bars == 10
+
+
+def test_config_validation_num_of_ring_error():
+    ring_config_0 = RingConfig(index=0)
+    ring_config_1 = RingConfig(index=1)
+
+    with pytest.raises(ValidationError) as excinfo:
+        SpiralProgressBarConfig(rings=[ring_config_0, ring_config_1], num_bars=1)
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == "different number of configs"
+    assert "Length of rings configuration (2) does not match the number of bars (1)." in str(
+        excinfo.value
+    )
+
+
+def test_config_validation_ring_indices_wrong_order():
+    ring_config_0 = RingConfig(index=2)
+    ring_config_1 = RingConfig(index=5)
+
+    with pytest.raises(ValidationError) as excinfo:
+        SpiralProgressBarConfig(rings=[ring_config_0, ring_config_1], num_bars=2)
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == "wrong indices"
+    assert (
+        "Indices of ring configurations must be unique and in order from 0 to num_bars 2."
+        in str(excinfo.value)
+    )
+
+
+def test_config_validation_ring_same_indices():
+    ring_config_0 = RingConfig(index=0)
+    ring_config_1 = RingConfig(index=0)
+
+    with pytest.raises(ValidationError) as excinfo:
+        SpiralProgressBarConfig(rings=[ring_config_0, ring_config_1], num_bars=2)
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == "wrong indices"
+    assert (
+        "Indices of ring configurations must be unique and in order from 0 to num_bars 2."
+        in str(excinfo.value)
+    )
+
+
+def test_config_validation_invalid_colormap():
+    with pytest.raises(ValueError) as excinfo:
+        SpiralProgressBarConfig(color_map="crazy_colors")
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == "unsupported colormap"
+    assert "Colormap 'crazy_colors' not found in the current installation of pyqtgraph" in str(
+        excinfo.value
+    )
+
+
+def test_ring_connection_endpoint_validation():
+    with pytest.raises(ValueError) as excinfo:
+        RingConnections(slot="on_scan_progress", endpoint="non_existing")
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == "unsupported endpoint"
+    assert (
+        "For slot 'on_scan_progress', endpoint must be MessageEndpoint.scan_progress or 'scans/scan_progress'."
+        in str(excinfo.value)
+    )
+
+    with pytest.raises(ValueError) as excinfo:
+        RingConnections(slot="on_device_readback", endpoint="non_existing")
+    errors = excinfo.value.errors()
+    assert len(errors) == 1
+    assert errors[0]["type"] == "unsupported endpoint"
+    assert (
+        "For slot 'on_device_readback', endpoint must be MessageEndpoint.device_readback(device) or 'internal/devices/readback/{device}'."
+        in str(excinfo.value)
+    )
+
+
+def test_bar_add_number_of_bars(spiral_progress_bar):
+    assert spiral_progress_bar.config.num_bars == 1
+
+    spiral_progress_bar.set_number_of_bars(5)
+    assert spiral_progress_bar.config.num_bars == 5
+
+    spiral_progress_bar.set_number_of_bars(2)
+    assert spiral_progress_bar.config.num_bars == 2
+
+
+def test_add_remove_bars_individually(spiral_progress_bar):
+    spiral_progress_bar.add_ring()
+    spiral_progress_bar.add_ring()
+
+    assert spiral_progress_bar.config.num_bars == 3
+    assert len(spiral_progress_bar.config.rings) == 3
+
+    spiral_progress_bar.remove_ring(1)
+    assert spiral_progress_bar.config.num_bars == 2
+    assert len(spiral_progress_bar.config.rings) == 2
+    assert spiral_progress_bar.rings[0].config.index == 0
+    assert spiral_progress_bar.rings[1].config.index == 1
+
+
+def test_bar_set_value(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(5)
+
+    assert spiral_progress_bar.config.num_bars == 5
+    assert len(spiral_progress_bar.config.rings) == 5
+    assert len(spiral_progress_bar.rings) == 5
+
+    spiral_progress_bar.set_value([10, 20, 30, 40, 50])
+    ring_values = [ring.value for ring in spiral_progress_bar.rings]
+    assert ring_values == [10, 20, 30, 40, 50]
+
+    # update just one bar
+    spiral_progress_bar.set_value(90, 1)
+    ring_values = [ring.value for ring in spiral_progress_bar.rings]
+    assert ring_values == [10, 90, 30, 40, 50]
+
+
+def test_bar_set_precision(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(3)
+
+    assert spiral_progress_bar.config.num_bars == 3
+    assert len(spiral_progress_bar.config.rings) == 3
+    assert len(spiral_progress_bar.rings) == 3
+
+    spiral_progress_bar.set_precision(2)
+    ring_precision = [ring.config.precision for ring in spiral_progress_bar.rings]
+    assert ring_precision == [2, 2, 2]
+
+    spiral_progress_bar.set_value([10.1234, 20.1234, 30.1234])
+    ring_values = [ring.value for ring in spiral_progress_bar.rings]
+    assert ring_values == [10.12, 20.12, 30.12]
+
+    spiral_progress_bar.set_precision(4, 1)
+    ring_precision = [ring.config.precision for ring in spiral_progress_bar.rings]
+    assert ring_precision == [2, 4, 2]
+
+    spiral_progress_bar.set_value([10.1234, 20.1234, 30.1234])
+    ring_values = [ring.value for ring in spiral_progress_bar.rings]
+    assert ring_values == [10.12, 20.1234, 30.12]
+
+
+def test_set_min_max_value(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(2)
+
+    spiral_progress_bar.set_min_max_values(0, 10)
+    ring_min_values = [ring.config.min_value for ring in spiral_progress_bar.rings]
+    ring_max_values = [ring.config.max_value for ring in spiral_progress_bar.rings]
+
+    assert ring_min_values == [0, 0]
+    assert ring_max_values == [10, 10]
+
+    spiral_progress_bar.set_value([5, 15])
+    ring_values = [ring.value for ring in spiral_progress_bar.rings]
+    assert ring_values == [5, 10]
+
+
+def test_setup_colors_from_colormap(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(5)
+    spiral_progress_bar.set_colors_from_map("viridis", "RGB")
+
+    expected_colors = Colors.golden_angle_color("viridis", 5, "RGB")
+    converted_colors = [ring.color.getRgb() for ring in spiral_progress_bar.rings]
+    ring_config_colors = [ring.config.color for ring in spiral_progress_bar.rings]
+
+    assert expected_colors == converted_colors
+    assert ring_config_colors == expected_colors
+
+
+def get_colors_from_rings(rings):
+    converted_colors = [ring.color.getRgb() for ring in rings]
+    ring_config_colors = [ring.config.color for ring in rings]
+    return converted_colors, ring_config_colors
+
+
+def test_set_colors_from_colormap_and_change_num_of_bars(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(2)
+    spiral_progress_bar.set_colors_from_map("viridis", "RGB")
+
+    expected_colors = Colors.golden_angle_color("viridis", 2, "RGB")
+    converted_colors, ring_config_colors = get_colors_from_rings(spiral_progress_bar.rings)
+
+    assert expected_colors == converted_colors
+    assert ring_config_colors == expected_colors
+
+    # increase the number of bars to 6
+    spiral_progress_bar.set_number_of_bars(6)
+    expected_colors = Colors.golden_angle_color("viridis", 6, "RGB")
+    converted_colors, ring_config_colors = get_colors_from_rings(spiral_progress_bar.rings)
+
+    assert expected_colors == converted_colors
+    assert ring_config_colors == expected_colors
+
+    # decrease the number of bars to 3
+    spiral_progress_bar.set_number_of_bars(3)
+    expected_colors = Colors.golden_angle_color("viridis", 3, "RGB")
+    converted_colors, ring_config_colors = get_colors_from_rings(spiral_progress_bar.rings)
+
+    assert expected_colors == converted_colors
+    assert ring_config_colors == expected_colors
+
+
+def test_set_colors_directly(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(3)
+
+    # setting as a list of rgb tuples
+    colors = [(255, 0, 0, 255), (0, 255, 0, 255), (0, 0, 255, 255)]
+    spiral_progress_bar.set_colors_directly(colors)
+    converted_colors = get_colors_from_rings(spiral_progress_bar.rings)[0]
+
+    assert colors == converted_colors
+
+    spiral_progress_bar.set_colors_directly((255, 0, 0, 255), 1)
+    converted_colors = get_colors_from_rings(spiral_progress_bar.rings)[0]
+
+    assert converted_colors == [(255, 0, 0, 255), (255, 0, 0, 255), (0, 0, 255, 255)]
+
+
+def test_set_line_width(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(3)
+
+    spiral_progress_bar.set_line_widths(5)
+    line_widths = [ring.config.line_width for ring in spiral_progress_bar.rings]
+
+    assert line_widths == [5, 5, 5]
+
+    spiral_progress_bar.set_line_widths([10, 20, 30])
+    line_widths = [ring.config.line_width for ring in spiral_progress_bar.rings]
+
+    assert line_widths == [10, 20, 30]
+
+    spiral_progress_bar.set_line_widths(15, 1)
+    line_widths = [ring.config.line_width for ring in spiral_progress_bar.rings]
+
+    assert line_widths == [10, 15, 30]
+
+
+def test_set_gap(spiral_progress_bar):
+    spiral_progress_bar.set_number_of_bars(3)
+    spiral_progress_bar.set_gap(20)
+
+    assert spiral_progress_bar.config.gap == 20
+
+
+def test_auto_update(spiral_progress_bar):
+    spiral_progress_bar.enable_auto_updates(True)
+
+    scan_queue_status_scan_progress = {
+        "queue": {
+            "primary": {
+                "info": [{"active_request_block": {"report_instructions": [{"scan_progress": 10}]}}]
+            }
+        }
+    }
+    meta = {}
+
+    spiral_progress_bar.on_scan_queue_status(scan_queue_status_scan_progress, meta)
+
+    assert spiral_progress_bar._auto_updates is True
+    assert len(spiral_progress_bar._rings) == 1
+    assert spiral_progress_bar._rings[0].config.connections == RingConnections(
+        slot="on_scan_progress", endpoint=MessageEndpoints.scan_progress()
+    )
+
+    scan_queue_status_device_readback = {
+        "queue": {
+            "primary": {
+                "info": [
+                    {
+                        "active_request_block": {
+                            "report_instructions": [
+                                {
+                                    "readback": {
+                                        "devices": ["samx", "samy"],
+                                        "start": [1, 2],
+                                        "end": [10, 20],
+                                    }
+                                }
+                            ]
+                        }
+                    }
+                ]
+            }
+        }
+    }
+    spiral_progress_bar.on_scan_queue_status(scan_queue_status_device_readback, meta)
+
+    assert spiral_progress_bar._auto_updates is True
+    assert len(spiral_progress_bar._rings) == 2
+    assert spiral_progress_bar._rings[0].config.connections == RingConnections(
+        slot="on_device_readback", endpoint=MessageEndpoints.device_readback("samx")
+    )
+    assert spiral_progress_bar._rings[1].config.connections == RingConnections(
+        slot="on_device_readback", endpoint=MessageEndpoints.device_readback("samy")
+    )
+
+    assert spiral_progress_bar._rings[0].config.min_value == 1
+    assert spiral_progress_bar._rings[0].config.max_value == 10
+    assert spiral_progress_bar._rings[1].config.min_value == 2
+    assert spiral_progress_bar._rings[1].config.max_value == 20

bec_widgets/examples/eiger_plot/eiger_plot.py

@@ -1,307 +0,0 @@
-import json
-import os
-import threading
-
-import h5py
-import numpy as np
-import pyqtgraph as pg
-import zmq
-from pyqtgraph.Qt import uic
-from qtpy.QtCore import Signal as pyqtSignal
-from qtpy.QtCore import Slot as pyqtSlot
-from qtpy.QtGui import QKeySequence
-from qtpy.QtWidgets import QDialog, QFileDialog, QFrame, QLabel, QShortcut, QVBoxLayout, QWidget
-
-# from scipy.stats import multivariate_normal
-
-
-class EigerPlot(QWidget):
-    update_signal = pyqtSignal()
-
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        # pg.setConfigOptions(background="w", foreground="k", antialias=True)
-
-        current_path = os.path.dirname(__file__)
-        uic.loadUi(os.path.join(current_path, "eiger_plot.ui"), self)
-
-        # Set widow name
-        self.setWindowTitle("Eiger Plot")
-
-        self.hist_lims = None
-        self.mask = None
-        self.image = None
-
-        # UI
-        self.init_ui()
-        self.hook_signals()
-        self.key_bindings()
-
-        # ZMQ Consumer
-        self._zmq_consumer_exit_event = threading.Event()
-        self._zmq_consumer_thread = self.start_zmq_consumer()
-
-    def close(self):
-        super().close()
-        self._zmq_consumer_exit_event.set()
-        self._zmq_consumer_thread.join()
-
-    def init_ui(self):
-        # Create Plot and add ImageItem
-        self.plot_item = pg.PlotItem()
-        self.plot_item.setAspectLocked(True)
-        self.imageItem = pg.ImageItem()
-        self.plot_item.addItem(self.imageItem)
-
-        # Setting up histogram
-        self.hist = pg.HistogramLUTItem()
-        self.hist.setImageItem(self.imageItem)
-        self.hist.gradient.loadPreset("magma")
-        self.update_hist()
-
-        # Adding Items to Graphical Layout
-        self.glw.addItem(self.plot_item)
-        self.glw.addItem(self.hist)
-
-    def hook_signals(self):
-        # Buttons
-        # self.pushButton_test.clicked.connect(self.start_sim_stream)
-        self.pushButton_mask.clicked.connect(self.load_mask_dialog)
-        self.pushButton_delete_mask.clicked.connect(self.delete_mask)
-        self.pushButton_help.clicked.connect(self.show_help_dialog)
-
-        # SpinBoxes
-        self.doubleSpinBox_hist_min.valueChanged.connect(self.update_hist)
-        self.doubleSpinBox_hist_max.valueChanged.connect(self.update_hist)
-
-        # Signal/Slots
-        self.update_signal.connect(self.on_image_update)
-
-    def key_bindings(self):
-        # Key bindings for rotation
-        rotate_plus = QShortcut(QKeySequence("Ctrl+A"), self)
-        rotate_minus = QShortcut(QKeySequence("Ctrl+Z"), self)
-        self.comboBox_rotation.setToolTip("Increase rotation: Ctrl+A\nDecrease rotation: Ctrl+Z")
-        self.checkBox_transpose.setToolTip("Toggle transpose: Ctrl+T")
-
-        max_index = self.comboBox_rotation.count() - 1  # Maximum valid index
-
-        rotate_plus.activated.connect(
-            lambda: self.comboBox_rotation.setCurrentIndex(
-                min(self.comboBox_rotation.currentIndex() + 1, max_index)
-            )
-        )
-
-        rotate_minus.activated.connect(
-            lambda: self.comboBox_rotation.setCurrentIndex(
-                max(self.comboBox_rotation.currentIndex() - 1, 0)
-            )
-        )
-
-        # Key bindings for transpose
-        transpose = QShortcut(QKeySequence("Ctrl+T"), self)
-        transpose.activated.connect(self.checkBox_transpose.toggle)
-
-        FFT = QShortcut(QKeySequence("Ctrl+F"), self)
-        FFT.activated.connect(self.checkBox_FFT.toggle)
-        self.checkBox_FFT.setToolTip("Toggle FFT: Ctrl+F")
-
-        log = QShortcut(QKeySequence("Ctrl+L"), self)
-        log.activated.connect(self.checkBox_log.toggle)
-        self.checkBox_log.setToolTip("Toggle log: Ctrl+L")
-
-        mask = QShortcut(QKeySequence("Ctrl+M"), self)
-        mask.activated.connect(self.pushButton_mask.click)
-        self.pushButton_mask.setToolTip("Load mask: Ctrl+M")
-
-        delete_mask = QShortcut(QKeySequence("Ctrl+D"), self)
-        delete_mask.activated.connect(self.pushButton_delete_mask.click)
-        self.pushButton_delete_mask.setToolTip("Delete mask: Ctrl+D")
-
-    def update_hist(self):
-        self.hist_levels = [
-            self.doubleSpinBox_hist_min.value(),
-            self.doubleSpinBox_hist_max.value(),
-        ]
-        self.hist.setLevels(min=self.hist_levels[0], max=self.hist_levels[1])
-        self.hist.setHistogramRange(
-            self.hist_levels[0] - 0.1 * self.hist_levels[0],
-            self.hist_levels[1] + 0.1 * self.hist_levels[1],
-        )
-
-    def load_mask_dialog(self):
-        options = QFileDialog.Options()
-        options |= QFileDialog.ReadOnly
-        file_name, _ = QFileDialog.getOpenFileName(
-            self, "Select Mask File", "", "H5 Files (*.h5);;All Files (*)", options=options
-        )
-        if file_name:
-            self.load_mask(file_name)
-
-    def load_mask(self, path):
-        try:
-            with h5py.File(path, "r") as f:
-                self.mask = f["data"][...]
-            if self.mask is not None:
-                # Set label to mask name without path
-                self.label_mask.setText(os.path.basename(path))
-        except KeyError as e:
-            # Update GUI with the error message
-            print(f"Error: {str(e)}")
-
-    def delete_mask(self):
-        self.mask = None
-        self.label_mask.setText("No Mask")
-
-    @pyqtSlot()
-    def on_image_update(self):
-        # TODO first rotate then transpose
-        if self.mask is not None:
-            # self.image = np.ma.masked_array(self.image, mask=self.mask) #TODO test if np works
-            self.image = self.image * (1 - self.mask) + 1
-
-        if self.checkBox_FFT.isChecked():
-            self.image = np.abs(np.fft.fftshift(np.fft.fft2(self.image)))
-
-        if self.comboBox_rotation.currentIndex() > 0:  # rotate
-            self.image = np.rot90(self.image, k=self.comboBox_rotation.currentIndex(), axes=(0, 1))
-
-        if self.checkBox_transpose.isChecked():  # transpose
-            self.image = np.transpose(self.image)
-
-        if self.checkBox_log.isChecked():
-            self.image = np.log10(self.image)
-
-        self.imageItem.setImage(self.image, autoLevels=False)
-
-    ###############################
-    # ZMQ Consumer
-    ###############################
-
-    def start_zmq_consumer(self):
-        consumer_thread = threading.Thread(
-            target=self.zmq_consumer, args=(self._zmq_consumer_exit_event,), daemon=True
-        )
-        consumer_thread.start()
-        return consumer_thread
-
-    def zmq_consumer(self, exit_event):
-        print("starting consumer")
-        live_stream_url = "tcp://129.129.95.38:20000"
-        receiver = zmq.Context().socket(zmq.SUB)
-        receiver.connect(live_stream_url)
-        receiver.setsockopt_string(zmq.SUBSCRIBE, "")
-
-        poller = zmq.Poller()
-        poller.register(receiver, zmq.POLLIN)
-
-        # code could be a bit simpler here, testing exit_event in
-        # 'while' condition, but like this it is easier for the
-        # 'test_zmq_consumer' test
-        while True:
-            if poller.poll(1000):  # 1s timeout
-                raw_meta, raw_data = receiver.recv_multipart(zmq.NOBLOCK)
-
-                meta = json.loads(raw_meta.decode("utf-8"))
-                self.image = np.frombuffer(raw_data, dtype=meta["type"]).reshape(meta["shape"])
-                self.update_signal.emit()
-            if exit_event.is_set():
-                break
-
-        receiver.disconnect(live_stream_url)
-
-    ###############################
-    # just simulations from here
-    ###############################
-
-    def show_help_dialog(self):
-        dialog = QDialog(self)
-        dialog.setWindowTitle("Help")
-
-        layout = QVBoxLayout()
-
-        # Key bindings section
-        layout.addWidget(QLabel("Keyboard Shortcuts:"))
-
-        key_bindings = [
-            ("Ctrl+A", "Increase rotation"),
-            ("Ctrl+Z", "Decrease rotation"),
-            ("Ctrl+T", "Toggle transpose"),
-            ("Ctrl+F", "Toggle FFT"),
-            ("Ctrl+L", "Toggle log scale"),
-            ("Ctrl+M", "Load mask"),
-            ("Ctrl+D", "Delete mask"),
-        ]
-
-        for keys, action in key_bindings:
-            layout.addWidget(QLabel(f"{keys} - {action}"))
-
-        # Separator
-        separator = QFrame()
-        separator.setFrameShape(QFrame.HLine)
-        separator.setFrameShadow(QFrame.Sunken)
-        layout.addWidget(separator)
-
-        # Histogram section
-        layout.addWidget(QLabel("Histogram:"))
-        layout.addWidget(
-            QLabel(
-                "Use the Double Spin Boxes to adjust the minimum and maximum values of the histogram."
-            )
-        )
-
-        # Another Separator
-        another_separator = QFrame()
-        another_separator.setFrameShape(QFrame.HLine)
-        another_separator.setFrameShadow(QFrame.Sunken)
-        layout.addWidget(another_separator)
-
-        # Mask section
-        layout.addWidget(QLabel("Mask:"))
-        layout.addWidget(
-            QLabel(
-                "Use 'Load Mask' to load a mask from an H5 file. 'Delete Mask' removes the current mask."
-            )
-        )
-
-        dialog.setLayout(layout)
-        dialog.exec()
-
-    ###############################
-    # just simulations from here
-    ###############################
-    # def start_sim_stream(self):
-    #     sim_stream_thread = threading.Thread(target=self.sim_stream, daemon=True)
-    #     sim_stream_thread.start()
-    #
-    # def sim_stream(self):
-    #     for i in range(100):
-    #         # Generate 100x100 image of random noise
-    #         self.image = np.random.rand(100, 100) * 0.2
-    #
-    #         # Define Gaussian parameters
-    #         x, y = np.mgrid[0:50, 0:50]
-    #         pos = np.dstack((x, y))
-    #
-    #         # Center at (25, 25) longer along y-axis
-    #         rv = multivariate_normal(mean=[25, 25], cov=[[25, 0], [0, 80]])
-    #
-    #         # Generate Gaussian in the first quadrant
-    #         gaussian_quadrant = rv.pdf(pos) * 40
-    #
-    #         # Place Gaussian in the first quadrant
-    #         self.image[0:50, 0:50] += gaussian_quadrant * 10
-    #
-    #         self.update_signal.emit()
-    #         time.sleep(0.1)
-
-
-if __name__ == "__main__":
-    import sys
-
-    from qtpy.QtWidgets import QApplication
-
-    app = QApplication(sys.argv)
-    plot = EigerPlot()
-    plot.show()
-    sys.exit(app.exec())