QuLab 2.4.0__cp312-cp312-macosx_10_13_universal2.whl

qulab/executor/utils.py

@@ -0,0 +1,107 @@
+from pathlib import Path
+
+from .load import load_workflow
+
+
+class Node:
+
+    def __init__(self, name: str):
+        self.name = name
+        self.dependents = []
+
+
+class Tree:
+
+    def __init__(self):
+        self.nodes = {}
+        self.heads = []
+
+    def add_node(self, node: str):
+        self.nodes[node] = Node(node)
+
+
+def dependent_tree(node: str, code_path: str | Path) -> dict[str, list[str]]:
+    '''
+    Returns a dict of nodes and their dependents.
+    '''
+    tree = {}
+    for n in load_workflow(node, code_path).depends()[0]:
+        tree[n] = dependent_tree(n, code_path)
+    return tree
+
+
+def workflow_template(deps: list[str]) -> str:
+    return f"""
+from loguru import logger
+
+import numpy as np
+
+
+# 多长时间应该检查一次校准实验，单位是秒。
+__timeout__ = 200
+
+def depends():
+    return [{deps!r}]
+
+
+def calibrate():
+    logger.info(f"run {{__name__}}")
+
+    # calibrate 是一个完整的校准实验，如power Rabi，Ramsey等。
+    # 你需要足够的扫描点，以使得后续的 analyze 可以拟合出合适的参数。
+
+    # 这里只是一个示例，实际上你需要在这里写上你的校准代码。
+    x = np.linspace(0, 2*np.pi, 101)
+    y = []
+    for i in x:
+        y.append(np.sin(i))
+
+    return x, y
+
+
+def analyze(*args, history):
+    import random
+
+    # 完整校准后的状态有两种：OK 和 Bad，分别对应校准成功和校准失败。
+    # 校准失败是指出现坏数据，无法简单通过重新运行本次校准解决，需要
+    # 检查前置步骤。
+    state = random.choice(['OK', 'Bad'])
+
+    # 参数是一个字典，包含了本次校准得到的参数，后续会更新到config表中。
+    parameters = {{'gate.R.Q1.params.amp':1}}
+
+    # 其他信息可以是任何可序列化的内容，你可以将你想要记录的信息放在这里。
+    # 下次校准分析时，这些信息也会在 history 参数中一起传入，帮助你在下
+    # 次分析时对比参考。
+    other_infomation = {{}}
+
+    return state, parameters, other_infomation
+
+
+def check():
+    logger.info(f"check {{__name__}}")
+
+    # check 是一个快速检查实验，用于检查校准是否过时。
+    # 你只需要少数扫描点，让后续的 check_analyze 知道参数是否漂移，数据
+    # 坏没坏就够了，不要求拟合。
+
+    # 这里只是一个示例，实际上你需要在这里写上你的检查代码。
+    x = np.linspace(0, 2*np.pi, 5)
+    y = []
+    for i in x:
+        y.append(np.sin(i))
+
+    return x, y
+
+
+def check_analyze(*args, history):
+    import random
+
+    # 状态有三种：Outdated, OK, Bad，分别对应过时、正常、坏数据。
+    # Outdated 是指数据过时，即参数漂了，需要重新校准。
+    # OK 是指数据正常，参数也没漂，不用重新校准。
+    # Bad 是指数据坏了，无法校准，需要检查前置步骤。
+    state = random.choice(['Outdated', 'OK', 'Bad'])
+
+    return state, {{}}, {{}}
+"""

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,93 @@
+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