QuLab 2.0.2__cp310-cp310-macosx_10_9_universal2.whl

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

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}")

qulab/monitor/toolbar.py

@@ -0,0 +1,265 @@
+import itertools
+import re
+from typing import Callable
+
+from .config import style
+from .qt_compat import AlignRight, QtWidgets
+
+
+def matched_xy_pairs(patterns: str, lst: list[str]) -> list[tuple[str, str]]:
+    patterns = patterns.replace(" ", "").split(";")
+    pairs = []
+    for x, y in itertools.product(lst, repeat=2):
+        test = f"{x},{y}"
+        for pattern in patterns:
+            r = re.match(pattern, test)
+            if r and r.group(0) == test:
+                pairs.append((x, y))
+                break
+    return pairs
+
+
+class FormatCombo(QtWidgets.QComboBox):
+
+    def __init__(self):
+        super().__init__()
+        self.on_change_callable = None
+
+    def set_on_change_event_action(self, callback: Callable[[], None]):
+        self.on_change_callable = callback
+        self.activated.connect(callback)
+
+    def set_idx(self, idx: int):
+        self.setCurrentIndex(idx)
+        if (callable(self.on_change_callable)):
+            self.on_change_callable()
+
+
+class XFormatCombo(FormatCombo):
+
+    def __init__(self):
+        super().__init__()
+        self.addItem("real")
+        self.addItem("imag")
+        self.addItem("mag")
+        self.addItem("phase")
+
+
+class YFormatCombo(FormatCombo):
+
+    def __init__(self):
+        super().__init__()
+        self.addItem("mag")
+        self.addItem("phase")
+        self.addItem("real")
+        self.addItem("imag")
+
+
+class LineEdit(QtWidgets.QLineEdit):
+
+    def set_on_change_event_action(self, callback: Callable[[], None]):
+        self.on_change_callable = callback
+        self.editingFinished.connect(callback)
+
+    def set_text(self, w):
+        self.setText(w)
+        if (callable(self.on_change_callable)):
+            self.on_change_callable()
+
+
+class SelectionBundle():
+
+    def __init__(self):
+        self.stx = LineEdit()
+        # select text
+        self.fx = XFormatCombo()
+        self.fy = YFormatCombo()
+        self.lx = QtWidgets.QCheckBox("logX")
+        self.ly = QtWidgets.QCheckBox("logY")
+        self.linkx = QtWidgets.QCheckBox("ShareX")
+        self.linky = QtWidgets.QCheckBox("ShareY")
+        self.sels = []
+        # tuple enumeration
+
+    def set_on_change_event_actions(self, on_text_edited, on_format_changed,
+                                    on_log_scale_marker_changed):
+        self.stx.set_on_change_event_action(on_text_edited)
+        self.fx.set_on_change_event_action(on_format_changed)
+        self.fy.set_on_change_event_action(on_format_changed)
+        self.lx.toggled.connect(on_format_changed)
+        self.ly.toggled.connect(on_format_changed)
+        self.linkx.toggled.connect(on_log_scale_marker_changed)
+        self.linky.toggled.connect(on_log_scale_marker_changed)
+
+    def rm4l(self):  # remove from layout
+        self.stx.setParent(None)
+        self.fx.setParent(None)
+        self.fy.setParent(None)
+        self.lx.setParent(None)
+        self.ly.setParent(None)
+        self.linkx.setParent(None)
+        self.linky.setParent(None)
+
+    def a2l(self, layout):  # add to layout
+        i = 3
+        layout.addWidget(self.stx, 0, i)
+        i += 2
+        layout.addWidget(self.fx, 0, i)
+        i += 2
+        layout.addWidget(self.fy, 0, i)
+        i += 2
+        layout.addWidget(self.lx, 0, 10)
+        layout.addWidget(self.ly, 0, 11)
+        layout.addWidget(self.linkx, 0, 12)
+        layout.addWidget(self.linky, 0, 13)
+
+
+class ToolBar(QtWidgets.QWidget):
+
+    def __init__(self):
+        super().__init__()
+
+        # the buttons
+        # button for points
+        self.mode = 'P'
+        self.setStyleSheet(style)
+
+        self.pb = QtWidgets.QRadioButton('Points')
+        self.pb.setChecked(True)
+        self.pb.toggled.connect(self.toggle_mode)
+
+        # button for Traces
+        self.tb = QtWidgets.QRadioButton('Traces')
+        self.tb.toggled.connect(self.toggle_mode)
+
+        # text labels
+        self.ytxt_lb = QtWidgets.QLabel("(X,Y)")
+        self.ytxt_lb.setAlignment(AlignRight)
+        self.fx_lb = QtWidgets.QLabel("fx")
+        self.fx_lb.setAlignment(AlignRight)
+        self.fy_lb = QtWidgets.QLabel("fy")
+        self.fy_lb.setAlignment(AlignRight)
+
+        # enumeration
+        ps = SelectionBundle()
+        ps.set_on_change_event_actions(self.textEdited, self.generateXYFM,
+                                       self.link_edited)
+
+        ts = SelectionBundle()
+        ts.set_on_change_event_actions(self.textEdited, self.generateXYFM,
+                                       self.link_edited)
+
+        # connections :
+        self.ps = ps
+        self.ts = ts
+
+        # plot format configures
+        self.xypairs = []
+        self.xypairs_dirty = True
+        self.fx = None
+        self.fy = None
+        self.xyfm_dirty = True
+        self.link_dirty = True
+        self.lx = False
+        self.ly = False
+        # setting layout
+        self.layout = QtWidgets.QGridLayout()
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(self.layout)
+
+        self.layout.addWidget(self.pb, 0, 0)
+        self.layout.addWidget(self.tb, 0, 1)
+
+        self.layout.addWidget(self.ytxt_lb, 0, 2)
+        self.layout.addWidget(self.fx_lb, 0, 4)
+        self.layout.addWidget(self.fy_lb, 0, 6)
+
+        self.AR = QtWidgets.QPushButton("AR")
+        self.AR.setMaximumWidth(30)
+        self.AR.setToolTip("Auto Range")
+        self.CR = QtWidgets.QPushButton("CLR")
+        self.CR.setMaximumWidth(30)
+        self.CR.setToolTip("Clearing History Plots")
+        self.CR_flag = False
+        self.layout.addWidget(self.AR, 0, 8)
+        self.layout.addWidget(self.CR, 0, 9)
+
+        self.refresh_layout()
+
+    @property
+    def column_names(self) -> list[str]:
+        return {
+            "P": self.mainwindow.point_data_box.column_names,
+            "T": self.mainwindow.trace_data_box.column_names
+        }[self.mode]
+
+    @property
+    def selections(self) -> SelectionBundle:
+        return {"P": self.ps, "T": self.ts}[self.mode]
+
+    def set_trace_text(self, text: str):
+        self.ts.stx.set_text(text)
+
+    def set_point_text(self, text: str):
+        self.ps.stx.set_text(text)
+
+    def sharexy(self):
+        return self.selections.linkx.isChecked(
+        ), self.selections.linky.isChecked()
+
+    def set_mainwindow(self, mainwindow):
+        self.mainwindow = mainwindow
+        self.AR.clicked.connect(self.mainwindow.all_enable_auto_range)
+        self.CR.clicked.connect(self.CR_action)
+
+    def AR_action(self):
+        self.mainwindow.enable_all_auto_range()
+
+    def CR_action(self):
+        self.CR_flag = True
+
+    def refresh_layout(self):
+        if self.mode == 'P':
+            self.ts.rm4l()
+            self.ps.a2l(self.layout)
+        elif self.mode == 'T':
+            self.ps.rm4l()
+            self.ts.a2l(self.layout)
+
+    def toggle_mode(self):
+        if (self.pb.isChecked()):
+            self.mode = 'P'
+        elif (self.tb.isChecked()):
+            self.mode = 'T'
+        self.refresh_layout()
+        self.refresh_comb()
+
+    def refresh_comb(self, ):
+        self.generateXYFM()
+        self.textEdited()
+        #set tooltips
+        self.ytxt_lb.setToolTip(str(self.column_names))
+
+    def link_edited(self):
+        # print("LinkEdited")
+        self.link_dirty = True
+
+    def generateXYFM(self):
+        self.fx = self.selections.fx.currentText()
+        self.fy = self.selections.fy.currentText()
+        self.lx = self.selections.lx.isChecked()
+        self.ly = self.selections.ly.isChecked()
+        self.xyfm_dirty = True
+        #self.show_info() ;
+
+    def textEdited(self):
+        new_pairs = matched_xy_pairs(self.selections.stx.text(),
+                                     self.column_names)
+        if (len(self.xypairs) != len(new_pairs)):
+            self.xypairs_dirty = True
+        else:
+            for i, xy in enumerate(new_pairs):
+                if (xy != self.xypairs[i]):
+                    self.xypairs_dirty = True
+                    break
+        self.xypairs = new_pairs

qulab/scan/__init__.py

@@ -0,0 +1,3 @@
+from .expression import Expression, Symbol
+from .query_record import get_record, lookup, lookup_list
+from .scan import Scan

qulab/scan/curd.py

@@ -0,0 +1,144 @@
+from datetime import date, datetime, timezone
+from typing import Sequence, Type, Union
+
+from sqlalchemy.orm import Query, Session, aliased
+from sqlalchemy.orm.exc import NoResultFound
+from sqlalchemy.orm.session import Session
+from waveforms.dicttree import foldDict
+
+from .models import Comment, Record, Report, Sample, Tag
+
+
+def tag(session: Session, tag_text: str) -> Tag:
+    """Get a tag from the database or create a new if not exists."""
+    try:
+        return session.query(Tag).filter(Tag.text == tag_text).one()
+    except NoResultFound:
+        tag = Tag(text=tag_text)
+        return tag
+
+
+def tag_it(session: Session, tag_text: str, obj: Union[Sample, Record,
+                                                       Report]) -> Tag:
+    """Tag an object."""
+    if obj.id is None:
+        session.add(obj)
+        obj.tags.append(tag(session, tag_text))
+    else:
+        session.query(type(obj)).filter(
+            type(obj).id == obj.id).one().tags.append(tag(session, tag_text))
+    session.commit()
+
+
+def get_object_with_tags(session: Session,
+                         cls: Union[Type[Comment], Type[Sample], Type[Record],
+                                    Type[Report]], *tags: str) -> Query:
+    """
+    Query objects with the given tags.
+
+    Parameters
+    ----------
+    session : :class:`sqlalchemy.orm.Session`
+        The database session.
+    cls : :class:`sqlalchemy.orm.Mapper`
+        The object class.
+    tags : str
+        The tags.
+
+    Returns
+    -------
+    :class:`sqlalchemy.orm.Query`
+        The query.
+    """
+    if isinstance(session, Query):
+        q = session
+    else:
+        q = session.query(cls)
+    if not hasattr(cls, 'tags'):
+        return []
+
+    aliase = {tag: aliased(Tag) for tag in tags}
+
+    for tag, a in aliase.items():
+        q = q.join(a, cls.tags)
+        if '*' in tag:
+            q = q.filter(a.text.like(tag.replace('*', '%')))
+        else:
+            q = q.filter(a.text == tag)
+    return q
+
+
+def query_record(session: Session,
+                 offset: int = 0,
+                 limit: int = 10,
+                 app: str | None = None,
+                 tags: Sequence[str] = (),
+                 before: datetime | date | None = None,
+                 after: datetime | date | None = None):
+    tz_offset = datetime.now(timezone.utc).astimezone().utcoffset()
+    table = {'header': ['ID', 'App', 'tags', 'created time'], 'body': []}
+    apps = sorted(
+        set([
+            n for n, *_ in get_object_with_tags(session.query(Record.app),
+                                                Record, *tags).all()
+        ]))
+    apps = foldDict(dict([(app, None) for app in apps]))
+
+    query = get_object_with_tags(session, Record, *tags)
+
+    if app is not None:
+        if app.endswith('*'):
+            query = query.filter(Record.app.like(app[:-1] + '%'))
+        else:
+            query = query.filter(Record.app == app)
+    if before is not None:
+        if isinstance(before, date):
+            before = datetime(before.year, before.month, before.day)
+        query = query.filter(Record.ctime <= before - tz_offset)
+    if after is not None:
+        if isinstance(after, date):
+            after = datetime(after.year, after.month, after.day)
+        query = query.filter(Record.ctime >= after - tz_offset)
+    total = query.count()
+    for r in query.order_by(Record.ctime.desc()).limit(limit).offset(offset):
+        tags = sorted([t.text for t in r.tags])
+        ctime = r.ctime + tz_offset
+        row = [r.id, r.app, tags, ctime]
+        table['body'].append(row)
+
+    return total, apps, table
+
+
+def update_tags(session: Session,
+                record_id: int,
+                tags: Sequence[str],
+                append: bool = False):
+    record = session.get(Record, record_id)
+    if record is None:
+        return False
+    if append:
+        old = [t.text for t in record.tags]
+        for t in old:
+            if t not in tags:
+                tags.append(t)
+    record.tags = [tag(session, t) for t in tags]
+    try:
+        session.commit()
+    except Exception:
+        session.rollback()
+        return False
+    return True
+
+
+def remove_tags(session: Session, record_id: int, tags: Sequence[str]):
+    record = session.get(Record, record_id)
+    if record is None:
+        return False
+    old = [t.text for t in record.tags]
+    record.tags = [tag(session, t) for t in old if t not in tags]
+    try:
+        session.commit()
+    except Exception:
+        session.rollback()
+        return False
+    return True