QuLab 2.10.10__cp313-cp313-win_amd64.whl

qulab/monitor/__init__.py

@@ -0,0 +1 @@
+from .monitor import Monitor, get_monitor

qulab/monitor/__main__.py

@@ -0,0 +1,8 @@
+import click
+
+from .monitor import Monitor
+
+
+@click.command(name='monitor')
+def main():
+    pass

qulab/monitor/config.py

@@ -0,0 +1,41 @@
+import numpy as np
+
+style = '''
+QWidget {
+    font: medium Ubuntu;
+    background-color: #011F2F;
+    font-size: 16px;
+    font-size: 16px;
+    color:#FFFFFF;
+}
+'''
+#
+Nroll = 6
+
+#  Format of the data.
+forms = {
+    "mag": lambda w, ang: np.abs(w),
+    "phase": lambda w, ang: np.angle(w),
+    "real": lambda w, ang: np.real(w),
+    "imag": lambda w, ang: np.imag(w),
+    "rot": lambda w, ang: np.real(np.exp(1j * ang) * np.array(w))
+}
+form_keys = list(forms.keys())
+#
+COL_SEL = (0, 0, 0)
+COL_UNSEL = (6, 6, 8)
+#
+
+defualt_colors = [
+    (200, 0, 0),
+    (55, 100, 180),
+    (40, 80, 150),
+    (30, 50, 110),
+    (25, 40, 70),
+    (25, 30, 50),
+]
+
+widths = [3, 2, 2, 2, 1, 1]
+SymSize = [5, 0, 0, 0, 0, 0]
+ridx = list(range(Nroll))
+ridx.reverse()

qulab/monitor/dataset.py

@@ -0,0 +1,77 @@
+from collections import defaultdict, deque
+
+from .config import Nroll
+
+PAUSE_TIME = 1
+
+Number = int | float | complex
+
+
+def remove_duplicates(input_list: list[str]) -> list[str]:
+    """
+    Remove duplicates from a list of strings, keeping the order of the elements.
+    """
+    return list(dict.fromkeys(input_list))
+
+
+class Dataset():
+
+    def __init__(self):
+        self.column_names = []
+        self.box = deque(maxlen=Nroll)
+        self.dirty = True
+
+    def clear(self):
+        self.box.clear()
+
+    def clear_history(self):
+        o = self.box.popleft()
+        self.box.clear()
+        self.box.appendleft(o)
+
+    def set_column_names(self, column_names: list[str]):
+        column_names = remove_duplicates(column_names)
+        if column_names != self.column_names:
+            self.clear()
+        self.column_names = column_names
+
+    def get_data(self, step: int, xname: str,
+                 yname: str) -> tuple[list[Number], list[Number]]:
+        try:
+            b = self.box[step]
+        except IndexError:
+            return [], []
+        return b[xname], b[yname]
+
+    def append(self, dataframe: list[Number] | list[list[Number]]):
+        if not dataframe:
+            return
+        try:
+            iter(dataframe[0])  # test if dataframe is a list of list
+            self._append_traces(dataframe)
+        except TypeError:
+            self._append_points(dataframe)
+
+    def roll(self):
+        self.box.appendleft(defaultdict(list))
+
+    def _append_points(self, points: list[Number]):
+        self.dirty = True
+        assert (len(points) == len(
+            self.column_names)), (f"-PointDataBox\n"
+                                  f"-ap\n"
+                                  f"-Length Must be same\n"
+                                  f"the column_names : {self.column_names}\n"
+                                  f"given data : {points}")
+        for name, p in zip(self.column_names, points):
+            self.box[0][name].append(p)
+
+    def _append_traces(self, traces: list[list[Number]]):
+        self.dirty = True
+        assert (len(traces) == len(
+            self.column_names)), (f"-TraceDataBox\n"
+                                  f"-at\n"
+                                  f"-Length Must be same\n"
+                                  f"the column_names : {self.column_names}\n"
+                                  f"given data : {traces}")
+        self.box.appendleft(dict(zip(self.column_names, traces)))

qulab/monitor/event_queue.py

@@ -0,0 +1,54 @@
+import warnings
+from multiprocessing import Queue
+
+from .dataset import Dataset
+from .toolbar import ToolBar
+
+
+class EventQueue():
+
+    def __init__(self, queue: Queue, toolbar: ToolBar, point_dataset: Dataset,
+                 trace_dataset: Dataset):
+        self.toolbar = toolbar
+        self.queue = queue
+        self.point_dataset = point_dataset
+        self.trace_dataset = trace_dataset
+
+    def flush(self):
+        while (not self.queue.empty()):
+            words = self.queue.get()
+            try:
+                assert (isinstance(
+                    words, tuple)), "QueueHandler - fifo Content must be tuple"
+                assert (
+                    len(words) == 2
+                ), "QueueHandler -the tuple must be like (\"command_type\" , \"DATA\")"
+                cmd, data = words
+                assert (isinstance(
+                    cmd, str)), "QueueHandler - the command should be a string"
+            except AssertionError as e:
+                warnings.warn(e.args[0])
+                continue
+
+            self.handle(cmd, data)
+
+    def handle(self, cmd, data):
+        match cmd:
+            case "PN":
+                self.point_dataset.set_column_names(data)
+                self.toolbar.refresh_comb()
+            case "TN":
+                self.trace_dataset.set_column_names(data)
+                self.toolbar.refresh_comb()
+            case "PD":
+                self.point_dataset.append(data)
+            case "TD":
+                self.trace_dataset.append(data)
+            case "ROLL":
+                self.point_dataset.roll()
+            case "PXY":
+                self.toolbar.set_point_text(data)
+            case "TXY":
+                self.toolbar.set_trace_text(data)
+            case _:
+                warnings.warn(f"QueueHandler - unknown command : {cmd}")

qulab/monitor/mainwindow.py

@@ -0,0 +1,234 @@
+from multiprocessing import Queue
+from typing import Literal
+
+from .config import forms, ridx, style
+from .dataset import Dataset
+from .event_queue import EventQueue
+from .ploter import PlotWidget
+from .qt_compat import (BottomDockWidgetArea, QtCore, QtWidgets,
+                        ScrollBarAlwaysOff, ScrollBarAlwaysOn,
+                        TopDockWidgetArea)
+from .toolbar import ToolBar
+
+
+class MainWindow(QtWidgets.QMainWindow):
+
+    def __init__(self,
+                 queue: Queue,
+                 ncols=3,
+                 plot_minimum_height=350,
+                 plot_colors: list[tuple[int, int, int]] | None = None):
+        super().__init__()
+        self.ncols = ncols
+        self.need_reshuffled = False
+        self.plot_minimum_height = plot_minimum_height
+        self.plot_widgets: list[PlotWidget] = []
+        self.plot_colors = plot_colors
+        self.toolbar = ToolBar()
+        self.trace_data_box = Dataset()
+        self.point_data_box = Dataset()
+        self.queue = EventQueue(queue, self.toolbar, self.point_data_box,
+                                self.trace_data_box)
+
+        self.init_ui()
+
+        self.timer = QtCore.QTimer()
+        self.timer.timeout.connect(self.update)
+        self.timer.start(250)
+
+    def init_ui(self):
+        self.setStyleSheet(style)
+        self.setMinimumHeight(500)
+        self.setMinimumWidth(700)
+        self.scroll = QtWidgets.QScrollArea(
+        )  # Scroll Area which contains the widgets, set as the centralWidget
+        self.widget = QtWidgets.QWidget(
+        )  # Widget that contains the collection of Vertical Box
+        self.layout = QtWidgets.QGridLayout()
+        self.widget.setLayout(self.layout)
+
+        #Scroll Area Properties
+        #self.setCorner(Qt.TopSection, Qt.TopDockWidgetArea);
+        self.scroll.setVerticalScrollBarPolicy(ScrollBarAlwaysOn)
+        self.scroll.setHorizontalScrollBarPolicy(ScrollBarAlwaysOff)
+        self.scroll.setWidgetResizable(True)
+        self.scroll.setWidget(self.widget)
+        self.setCentralWidget(self.scroll)
+
+        self.dock = QtWidgets.QDockWidget(self)
+        self.dock.setAllowedAreas(TopDockWidgetArea | BottomDockWidgetArea)
+        self.addDockWidget(TopDockWidgetArea, self.dock)
+        self.dock.setFloating(False)
+        self.dock.setWidget(self.toolbar)
+        self.dock.setFeatures(QtWidgets.QDockWidget.DockWidgetMovable)
+        #self.tabifyDockWidget(self.dock,None);
+        #self.addDockWidget(self.dock);
+        #self.setStatusBar(self.toolbar);
+        #self.layout.addWidget(self.toolbar , 0 , 0  , 1, self.ncol);
+
+        self.setWindowTitle('Scroll multi view')
+        self.show()
+        self.toolbar.set_mainwindow(self)
+        self.toolbar.pb.setChecked(True)
+
+    @property
+    def mode(self) -> Literal["P", "T"]:
+        return self.toolbar.mode
+
+    @property
+    def dataset(self) -> Dataset:
+        return {"P": self.point_data_box, "T": self.trace_data_box}[self.mode]
+
+    def set_ncols(self, x: int):
+        x = max(1, min(10, int(x)))
+        if (x != self.ncols):
+            self.need_reshuffled = True
+            self.ncols = x
+
+    def add_subplot(self):
+        n = len(self.plot_widgets)
+        pw = PlotWidget(self.plot_minimum_height, self.plot_colors)
+        self.plot_widgets.append(pw)
+        grid_row = n // self.ncols
+        grid_col = n % self.ncols
+        self.layout.addWidget(pw, grid_row + 1, grid_col)
+        return pw
+
+    def create_subplots(self, xy_pairs):
+        for xn, yn in xy_pairs:
+            pw = self.add_subplot()
+            pw.set_X_label(xn)
+            pw.set_Y_label(yn)
+        self.do_link()
+        self.all_enable_auto_range()
+
+    def clear_subplots(self):
+        for i in range(len(self.plot_widgets)):
+            self.layout.removeWidget(self.plot_widgets[i])
+            self.plot_widgets[i].setParent(None)
+        self.plot_widgets.clear()
+
+    def remove_plot(self, w: PlotWidget):
+        w.setParent(None)
+        self.plot_widgets.remove(w)
+        self.reshuffle()
+
+    def drop_last_plot(self, i_=-1):
+        # delete the one
+        i = int(i_)
+        if (i < len(self.plot_widgets)):
+            w = self.plot_widgets[i]
+            w.setParent(None)
+            del w
+            del self.plot_widgets[i]
+        self.reshuffle()
+
+    def reshuffle(self):
+        for idx, widget in enumerate(self.plot_widgets):
+            widget.setParent(None)
+            grid_row = idx // self.ncols
+            grid_col = idx % self.ncols
+            self.layout.addWidget(widget, grid_row + 1, grid_col)
+
+    def keyPressEvent(self, ev):
+        #print(ev.text());
+        tx = ev.text()
+        if (tx in ['_', '-']):
+            self.set_ncols(self.ncols - 1)
+        elif (tx in ['=', '+']):
+            self.set_ncols(self.ncols + 1)
+
+    def mouse_click(self):
+        pass
+
+    def do_link(self):
+        """
+        link the plot
+
+        share the same x or y axis
+        """
+        same_X = {}
+        xy_pairs = self.toolbar.xypairs
+        for idx, xyn in enumerate(xy_pairs):
+            xn, yn = xyn
+            if xn not in same_X:
+                same_X[xn] = []
+            same_X[xn].append(idx)
+
+        sharex, sharey = self.toolbar.sharexy()
+
+        s_A = not (sharex and sharey)
+        for x, yidxs in same_X.items():
+            pre_yidx = -1
+            for yidx in yidxs:
+                if (-1 != pre_yidx):
+                    if (s_A):
+                        self.plot_widgets[pre_yidx].plotItem.vb.setXLink(None)
+                        self.plot_widgets[pre_yidx].plotItem.vb.setYLink(None)
+
+                    if sharex:
+                        self.plot_widgets[pre_yidx].plotItem.vb.setXLink(
+                            self.plot_widgets[yidx].plotItem.vb)
+
+                    if sharey:
+                        self.plot_widgets[pre_yidx].plotItem.vb.setYLink(
+                            self.plot_widgets[yidx].plotItem.vb)
+                pre_yidx = yidx
+
+    def all_auto_range(self):
+        for pw in self.plot_widgets:
+            pw.auto_range()
+
+    def all_enable_auto_range(self):
+        for pw in self.plot_widgets:
+            pw.enable_auto_range()
+
+    def update(self):
+        # update the queue
+        self.queue.flush()
+
+        rescale = False
+
+        # setup the xyfm
+        if (self.toolbar.xypairs_dirty):
+            self.clear_subplots()
+            self.create_subplots(self.toolbar.xypairs)
+            self.toolbar.xypairs_dirty = False
+            rescale = True
+
+        if (self.toolbar.link_dirty):
+            self.do_link()
+            self.toolbar.link_dirty = False
+
+        if (self.need_reshuffled):
+            self.need_reshuffled = False
+            self.reshuffle()
+
+        # checking the log space
+        if (self.toolbar.xyfm_dirty):
+            for pw in self.plot_widgets:
+                pw.plotItem.ctrl.logXCheck.setChecked(self.toolbar.lx)
+                pw.plotItem.ctrl.logYCheck.setChecked(self.toolbar.ly)
+
+        #update the plot
+        # if clear is set then do the clear :
+        if (self.toolbar.CR_flag):
+            self.toolbar.CR_flag = False
+            self.dataset.clear_history()
+            self.dataset.dirty = True
+
+        if (self.dataset.dirty or self.toolbar.xyfm_dirty or rescale):
+            self.dataset.dirty = False
+            self.xyfm_dirty = False
+            for pw in self.plot_widgets:
+
+                fx = forms[self.toolbar.fx]
+                fy = forms[self.toolbar.fy]
+                for i in ridx:
+                    x, y = self.dataset.get_data(i, pw.xname, pw.yname)
+                    l = min(len(x), len(y))
+                    x, y = fx(x[:l], 0), fy(y[:l], 0)
+                    pw.set_data(i, x, y)
+                pw.update()
+                if rescale:
+                    pw.auto_range()

qulab/monitor/monitor.py

@@ -0,0 +1,115 @@
+import multiprocessing as mp
+import sys
+
+# try:
+#     mp.set_start_method("spawn")
+# except:
+#     pass
+
+
+def main(queue: mp.Queue,
+         ncols: int = 4,
+         minimum_height: int = 400,
+         colors: list[tuple[int, int, int]] = []):
+    from .mainwindow import MainWindow
+    from .qt_compat import QtWidgets
+
+    app = QtWidgets.QApplication(sys.argv)
+    main = MainWindow(queue, ncols, minimum_height, colors)
+    sys.exit(app.exec())
+
+
+class Monitor():
+
+    def __init__(self,
+                 number_of_columns: int = 4,
+                 minimum_height: int = 400,
+                 colors: list[tuple[int, int, int]] = []):
+        self.colors = [tuple(color) for color in colors]
+        self.number_of_columns = number_of_columns
+        self.minimum_height = minimum_height
+        self.queue = mp.Queue(20)
+        self.process = None
+        self.start()
+
+    def start(self):
+        if self.process is not None and self.process.is_alive():
+            return
+        self.queue = mp.Queue(20)
+        self.process = mp.Process(target=main,
+                                  args=(self.queue, self.number_of_columns,
+                                        self.minimum_height, self.colors))
+        self.process.start()
+
+    def _put(self, w: tuple):
+        self.queue.put(w)
+
+    def roll(self):
+        self._put(("ROLL", None))
+
+    def set_column_names(self, *arg):
+        self._put(('PN', list(arg)))
+
+    def add_point(self, *arg):
+        self._put(('PD', list(arg)))
+
+    def set_plots(self, arg):
+        """
+        arg: str, like "(x,y)" or "(x1,y1);(x2,y2);"
+        """
+        self._put(('PXY', str(arg)))
+
+    def set_trace_column_names(self, *arg):
+        self._put(('TN', list(arg)))
+
+    def add_trace(self, *arg):
+        self._put(('TD', list(arg)))
+
+    def set_trace_plots(self, arg):
+        """
+        arg: str, like "(x,y)" or "(x1,y1);(x2,y2);"
+        """
+        self._put(('TXY', str(arg)))
+
+    def __del__(self):
+        try:
+            self.process.kill()
+        except:
+            pass
+
+    def is_alive(self):
+        return self.process.is_alive()
+
+
+_monitor = None
+
+
+def get_monitor(auto_open=True):
+    global _monitor
+
+    if auto_open and (_monitor is None or not _monitor.is_alive()):
+        _monitor = Monitor()
+
+    return _monitor
+
+
+if __name__ == "__main__":
+    import time
+
+    import numpy as np
+
+    for i in range(3):
+        index = 0
+        while True:
+            if index >= 100:
+                break
+
+            m = get_monitor()
+
+            if index == 0:
+                m.set_column_names("index", "H", "S")
+                m.set_plots("(index,H);(index,S)")
+                m.roll()
+            m.add_point(index, np.random.randn(), np.sin(index / 20))
+            index += 1
+            time.sleep(0.2)

qulab/monitor/ploter.py

@@ -0,0 +1,123 @@
+from .config import COL_SEL, COL_UNSEL, SymSize, defualt_colors, ridx, widths
+from .qt_compat import QtWidgets
+
+# the plotting widget
+try:
+    import pyqtgraph as pg
+except:
+    raise ImportError("Please install pyqtgraph first")
+
+try:
+    import pyperclip as pc
+    hasCliper = True
+except:
+    hasCliper = False
+
+
+class PlotWidget(pg.PlotWidget):
+
+    def __init__(self, minimum_height=300, colors=None):
+        self.XAxisLinked = False
+        self.YAxisLinked = False
+        if colors is None:
+            colors = defualt_colors
+        elif len(colors) < len(defualt_colors):
+            colors.extend(defualt_colors[len(colors):])
+        self.colors = colors
+        self.xname = ""
+        self.yname = ""
+        super().__init__()
+
+        self.setMinimumHeight(minimum_height)
+        self.showGrid(x=True, y=True)
+        self.setBackground(COL_UNSEL)
+
+        self.plotItem.vb.autoRange()
+
+        ## Labeling
+        self.XLabel = QtWidgets.QLabel(self)
+        self.XLabel.setText("X:")
+        self.XLabel.move(0, 5)
+        self.YLabel = QtWidgets.QLabel(self)
+        self.YLabel.setText("Y:")
+        self.YLabel.move(0, 35)
+
+        self.plots = {}
+        self.clippos1 = 0
+        self.clippos2 = 0
+        self.range_select = False
+        for i in ridx:
+            self.plots[i] = \
+              self.plot([],[] ,pen={"color":self.colors[i]  ,"width":widths[i]} ,
+                  symbolBrush = self.colors[i],
+                  symbolPen = { "width":0 ,"color":self.colors[i] }   ,
+                  symbolSize =SymSize[i] ,
+              )
+        self.update()
+
+    def set_X_label(self, w):
+        self.xname = w
+        self.XLabel.setText(f"X:{w}")
+
+    def set_Y_label(self, w):
+        self.yname = w
+        self.YLabel.setText(f"Y:{w}")
+
+    def auto_range(self):
+        self.plotItem.vb.autoRange()
+
+    def enable_auto_range(self):
+        self.plotItem.vb.enableAutoRange()
+
+    def keyPressEvent(self, ev):
+        #print(ev.text());
+        tx = ev.text()
+        if ('f' == tx or 'F' == tx):
+            self.plotItem.vb.autoRange()
+        if ('a' == tx or 'A' == tx):
+            self.plotItem.vb.setAutoPan()
+        if ('r' == tx or 'R' == tx):
+            self.range_select = True
+        super().keyPressEvent(ev)
+
+    def keyReleaseEvent(self, ev):
+        #print(ev.text());
+        tx = ev.text()
+        if ('f' == tx or 'F' == tx):
+            self.plotItem.vb.autoRange()
+        if ('a' == tx or 'A' == tx):
+            self.plotItem.vb.setAutoPan()
+        if ('r' == tx or 'R' == tx):
+            self.range_select = False
+        super().keyReleaseEvent(ev)
+
+    def mousePressEvent(self, ev):
+        if (4 == ev.button()):
+            # print(ev.flags())
+            if (hasCliper):
+                # print("Mouse is pressed")
+                self.clippos1 = self.plotItem.vb.mapSceneToView(ev.pos()).x()
+        else:
+            super().mousePressEvent(ev)
+
+    def mouseReleaseEvent(self, ev):
+        if (4 == ev.button()):
+            p = ev.pos()
+            if (hasCliper):
+                # print("Mouse is released")
+                self.clippos2 = self.plotItem.vb.mapSceneToView(ev.pos()).x()
+                if (self.range_select):
+                    pc.copy(f"{self.clippos1},{self.clippos2}")
+                else:
+                    pc.copy(self.clippos2)
+        else:
+            super().mouseReleaseEvent(ev)
+
+    def update(self):
+        super().update()
+
+    def set_data(self, i, x, y):
+        self.plots[i].setData(x, y)
+
+    # def mouseDoubleClickEvent(self, ev):
+    #     super().mouseDoubleClickEvent(ev)

qulab/monitor/qt_compat.py

@@ -0,0 +1,16 @@
+from matplotlib.backends.qt_compat import QT_API, QtCore, QtWidgets
+
+if QT_API in ['PySide6', 'PyQt6']:
+    AlignRight = QtCore.Qt.AlignmentFlag.AlignRight
+    BottomDockWidgetArea = QtCore.Qt.DockWidgetArea.BottomDockWidgetArea
+    ScrollBarAlwaysOn = QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOn
+    ScrollBarAlwaysOff = QtCore.Qt.ScrollBarPolicy.ScrollBarAlwaysOff
+    TopDockWidgetArea = QtCore.Qt.DockWidgetArea.TopDockWidgetArea
+elif QT_API in ['PyQt5', 'PySide2']:
+    AlignRight = QtCore.Qt.AlignRight
+    BottomDockWidgetArea = QtCore.Qt.BottomDockWidgetArea
+    ScrollBarAlwaysOn = QtCore.Qt.ScrollBarAlwaysOn
+    ScrollBarAlwaysOff = QtCore.Qt.ScrollBarAlwaysOff
+    TopDockWidgetArea = QtCore.Qt.TopDockWidgetArea
+else:
+    raise AssertionError(f"Unexpected QT_API: {QT_API}")