QuLab 2.0.1__cp310-cp310-win_amd64.whl

QuLab-2.0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 feihoo87
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

QuLab-2.0.1.dist-info/METADATA

@@ -0,0 +1,95 @@
+Metadata-Version: 2.1
+Name: QuLab
+Version: 2.0.1
+Summary: contral instruments and manage data
+Author-email: feihoo87 <feihoo87@gmail.com>
+Maintainer-email: feihoo87 <feihoo87@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/feihoo87/QuLab
+Project-URL: Bug Reports, https://github.com/feihoo87/QuLab/issues
+Project-URL: Source, https://github.com/feihoo87/QuLab/
+Keywords: experiment,laboratory
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Topic :: Scientific/Engineering :: Interface Engine/Protocol Translator
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: blinker >=1.4
+Requires-Dist: click >=7.1.2
+Requires-Dist: dill >=0.3.6
+Requires-Dist: GitPython >=3.1.14
+Requires-Dist: ipython >=7.4.0
+Requires-Dist: ipywidgets >=7.4.2
+Requires-Dist: matplotlib >=3.7.2
+Requires-Dist: numpy >=1.13.3
+Requires-Dist: ply >=3.11
+Requires-Dist: scipy >=1.0.0
+
+# QuLab
+[![View build status](https://travis-ci.org/feihoo87/QuLab.svg?branch=master)](https://travis-ci.org/feihoo87/QuLab)
+[![Coverage Status](https://coveralls.io/repos/github/feihoo87/QuLab/badge.svg)](https://coveralls.io/github/feihoo87/QuLab)
+[![Updates](https://pyup.io/repos/github/feihoo87/QuLab/shield.svg)](https://pyup.io/repos/github/feihoo87/QuLab/)
+[![Docs Status](https://readthedocs.org/projects/qulab/badge/?version=latest)](http://qulab.readthedocs.org)
+[![PyPI version](https://badge.fury.io/py/QuLab.svg)](https://badge.fury.io/py/QuLab)
+[![](https://img.shields.io/badge/python-3.6%2C%203.7-brightgreen.svg)]()
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3352232.svg)](https://doi.org/10.5281/zenodo.3352232)
+
+**Documentation can be found at [qulab.readthedocs.org](https://qulab.readthedocs.org/).**
+
+## Installation
+We encourage installing QuLab via the pip tool (a python package manager):
+```bash
+python -m pip install QuLab
+```
+
+To install from the latest source, you need to clone the GitHub repository on your machine.
+```bash
+git clone https://github.com/feihoo87/QuLab.git
+```
+
+Then dependencies and QuLab can be installed in this way:
+```bash
+cd QuLab
+python -m pip install -e .
+```
+
+## Usage
+
+
+## Running Tests
+To run tests:
+
+```
+python -m pip install -r requirements-dev.txt
+python -m pytest
+```
+
+## Attribution
+If you make use of this code, please consider citing the Zenodo DOI [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.3352232.svg)](https://doi.org/10.5281/zenodo.3352232) as a software citation:
+```
+@misc{xu_huikai_2019_3352232,
+  author       = {Xu, Huikai},
+  title        = {QuLab},
+  month        = aug,
+  year         = 2019,
+  doi          = {10.5281/zenodo.3352232},
+  url          = {https://doi.org/10.5281/zenodo.3352232}
+}
+```
+
+## Reporting Issues
+Please report all issues [on github](https://github.com/feihoo87/QuLab/issues).
+
+## License
+
+[MIT](https://opensource.org/licenses/MIT)

QuLab-2.0.1.dist-info/RECORD

@@ -0,0 +1,82 @@
+qulab/__init__.py,sha256=8zLGg-DfQhnDl2Ky0n-zXpN-8e-g7iR0AcaI4l4Vvpk,32
+qulab/__main__.py,sha256=pprldpRI_kZ3ufoH1JByhi7WIqqwW7MpaRoL0kGchQk,395
+qulab/fun.cp310-win_amd64.pyd,sha256=l5oopTAYLKn4EJwOrkrJqbBOd4ieZjzq1a2nap-3nhU,31232
+qulab/version.py,sha256=pMl7p0vBanIg04EfboBE80RyG_KP7M0m9V3-qTl0YLQ,21
+qulab/monitor/__init__.py,sha256=xEVDkJF8issrsDeLqQmDsvtRmrf-UiViFcGTWuzdlFU,43
+qulab/monitor/__main__.py,sha256=k2H1H5Zf9LLXTDLISJkbikLH-z0f1e5i5i6wXXYPOrE,105
+qulab/monitor/config.py,sha256=y_5StMkdrbZO1ziyKBrvIkB7Jclp9RCPK1QbsOhCxnY,785
+qulab/monitor/dataset.py,sha256=199kx7A08XKDnUN8MUZ7Cl4bWf52M0Mx7jrZLRyTwhw,2532
+qulab/monitor/event_queue.py,sha256=0fj-iP4g6rKaxyom-bL-NoecwPe48V1LlVLoRuGgX_Q,1877
+qulab/monitor/mainwindow.py,sha256=qqw7O9PTTrPjKgZAi7fS14S-fylTK9pzO1tAXtaNNAA,8033
+qulab/monitor/monitor.py,sha256=2AP-hhg1T6-38mieDm5_ONTIXnXYlIrSyOiAOxDKy0I,2398
+qulab/monitor/ploter.py,sha256=dg7W28XTwEbBxHVtdPkFV135OQgoQwTi-NJCZQF-HYU,3724
+qulab/monitor/qt_compat.py,sha256=Eq7zlA4_XstB92NhtAqebtWU_Btw4lcwFO30YxZ-TPE,804
+qulab/monitor/toolbar.py,sha256=HxqG6ywKFyQJM2Q1s7SnhuzjbyeROczAZKwxztD1WJ8,8213
+qulab/scan/__init__.py,sha256=sjw3_wUL8G2AyDKSl9jhvoCbqLGg2DEmloXJHfO067A,220
+qulab/scan/base.py,sha256=4KYjT42qNuIc1axac6Qz4Tkcu9_ZtEpZ1QhxDS17haI,17691
+qulab/scan/dataset.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/scan/expression.py,sha256=aTHplJPlvuW2R73X6oMcV5Gzeo8NSCre8Q3hE7mkCxI,15253
+qulab/scan/optimize.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/scan/scanner.py,sha256=PXQwFPkpUIMwoL40FFbXvk693eXxP7YYaHQHAY1Ome4,8072
+qulab/scan/transforms.py,sha256=OWiHE36qKqeOJI-vwo3BOjGi5Ya_xcYU0g7D2DDIGo4,268
+qulab/scan/utils.py,sha256=DHGC-RcGbY7RmMEDvazPkC_nFqlj_N8Cr9spm_CGfuE,1061
+qulab/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/storage/__main__.py,sha256=6-EjN0waX1yfcMPJXqpIr9UlrIEsSCFApm5G-ZeaPMQ,1742
+qulab/storage/base_dataset.py,sha256=28y3-OZrqJ52p5sbirEpUgjb7hqwLLpd38KU9DCkD24,12217
+qulab/storage/chunk.py,sha256=gfj6EhQbaFbgzRdPZpMc2HV75RIQJ-iQeq_ULQp6g9E,1761
+qulab/storage/dataset.py,sha256=mH5UTI3RbuWqsSnjvmVz1BJ_MoEyYFNhyDD-Ng1P6N8,4782
+qulab/storage/file.py,sha256=HplZpmYu1onC_lb7QuZ5DMRiabW6GU_beaxkixY5KfQ,8616
+qulab/storage/storage.py,sha256=Lb_MVORuwu3DZsXos0M18T10MGDlz4pGWsEseUAib5k,2656
+qulab/storage/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/storage/backend/redis.py,sha256=M6nsJc6dWMCjz57-EeCPcMpsuuyV6hUal2fcCr9D9a4,5406
+qulab/storage/models/__init__.py,sha256=4eS_O6ErY8sMCgLt2wEhTHcPvi0ebJGo7smLbvo7YjU,608
+qulab/storage/models/base.py,sha256=nImgJcUGdesnEAcPdF0YzT6td7jeod2CUDsVL7jQkCE,118
+qulab/storage/models/config.py,sha256=I6g5m76ePkDJ9Tr2xB0SAJwDu6jupCQvu1XGIKTPj2g,717
+qulab/storage/models/file.py,sha256=x8h8QbmkhJBZo2REjFFYYbR_SV5OWvZ6Ghpiy1SY2FE,2805
+qulab/storage/models/ipy.py,sha256=ZjflbhUNNjPcRcrXvZung72Y8oGPHWZnJTMoa0x706U,1632
+qulab/storage/models/models.py,sha256=h7nPI0uctftbxe8_cu3WkF59tKS4BuAIGCBmaHsuRBc,2967
+qulab/storage/models/record.py,sha256=F5yu-Sf1aK9pkfCihb2AUU8b5HLlYZAUzrkUkBDpx_4,5131
+qulab/storage/models/report.py,sha256=WO_hahL3VwWn3vn8tFZQ2ffYahV7RllIlAJPFmbVkdA,820
+qulab/storage/models/tag.py,sha256=KPpiEm0SHI613-XLu3NBYE-qeIO9gwuKPw6se2obgPw,2432
+qulab/sys/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/sys/chat.py,sha256=t7wSlREOQ_Ke0pO9bfpkik9wY1qeiTbRF1dial9IbII,23137
+qulab/sys/ipy_events.py,sha256=rGjsApv58_Gwd_TH6ecPnyXK34_ZYZsaX8tk32ozLGY,3014
+qulab/sys/progress.py,sha256=2iYskzRdOC2EM4wtbzm0u1kovjGrF_A0W1kCxbftyzE,5540
+qulab/sys/device/__init__.py,sha256=ZZxPJ9_MHModvghQoZOSWjIdeo3vhg2TJETDdrwQvkU,152
+qulab/sys/device/basedevice.py,sha256=8VOBArKnv_kAq9E4RO-J0Y5-xpqKIdTKozV9w8NK8FY,6644
+qulab/sys/device/loader.py,sha256=G9x78jV5OX9npHvn-Xz05cjjurwn1HPXT5fUlTV4i70,2587
+qulab/sys/device/utils.py,sha256=yQYnpzXy6Z81u5LnE70dWtB7vQ2O-F74s4uD9TY6AHc,1610
+qulab/sys/drivers/FakeInstrument.py,sha256=UBPjolpn8-ueo6-OexbepQL54DQnZrzbSCSiIbEcMak,1919
+qulab/sys/drivers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/sys/net/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/sys/net/bencoder.py,sha256=tsMjTG-E_EQokfWrZgJvxO3dTGaM6NOVzPPKsify23A,5164
+qulab/sys/net/cli.py,sha256=B3whPuhwBhlKiFvpdLK-FTv2EYE1U8tYWyUYNq9K5qs,5859
+qulab/sys/net/dhcp.py,sha256=zKd4jQvSc8xYr7PcyR0tLlChpUYBb-WUr7-RzKBnClM,24052
+qulab/sys/net/dhcpd.py,sha256=NB3lVTdk8xkwf4B-v9pOB0ylNj6SbYELGLSPgEQkOak,5498
+qulab/sys/net/kad.py,sha256=uf9bNU2M3JLk6ZH04PDEdrChs4OOkHYoBHYodGIn_WE,40123
+qulab/sys/net/kcp.py,sha256=NUDSkCXAneZoL-KDi_yGNfIdWycSCJRSpH0KL-tvpVQ,5952
+qulab/sys/net/nginx.py,sha256=dxpBmgj-Nw32FR4P3frh1FdENodUUpoICcdKiewYaLY,5156
+qulab/sys/rpc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/sys/rpc/client.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/sys/rpc/exceptions.py,sha256=ZXfQYcF9MhUp4tvm7LI6h0jKbF8LUStEOfiW-keoGC0,2663
+qulab/sys/rpc/msgpack.py,sha256=H2ujTA-6q41eQB-HBU0d_3LdGzWqL7EYQfDbPEfu4zQ,36378
+qulab/sys/rpc/msgpack.pyi,sha256=P_tQdQ9L1-Zw6ZR07Eg3Yr-6AhmWCMLbEMFgr5JHke4,1314
+qulab/sys/rpc/rpc.py,sha256=LVqOj7786kU8HrrF4ZVicIDp1aNkafyjBvhz9WJkDfE,12391
+qulab/sys/rpc/serialize.py,sha256=tCrXmdDPw5CacCC2VoY0bbB4qeAGnvPh6UFwfXgVIoA,3494
+qulab/sys/rpc/server.py,sha256=W3bPwe8um1IeR_3HLx-ad6iCcbeuUQcSg11Ze4w6DJg,742
+qulab/sys/rpc/socket.py,sha256=W3bPwe8um1IeR_3HLx-ad6iCcbeuUQcSg11Ze4w6DJg,742
+qulab/sys/rpc/utils.py,sha256=BurIcqh8CS-Hsk1dYP6IiefK4qHivaEqD9_rBY083SA,619
+qulab/sys/rpc/worker.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/visualization/__init__.py,sha256=Bkt9AK5c45d6HFLlT-f8cIppywXziHtJqhDtVxOoKKo,6317
+qulab/visualization/__main__.py,sha256=WduINFl21B-XMsi2rg2cVhIyU11hKKX3zOsjc56QLiQ,1710
+qulab/visualization/_autoplot.py,sha256=JLvyr36wQRUU7i61_TMqcODizWZvTizY5CSGS_ZZsCw,14234
+qulab/visualization/plot_layout.py,sha256=yAnMONOms7_szCdng-8wPpUMPis5UnbaNNzV4KFBgso,13941
+qulab/visualization/plot_seq.py,sha256=h9D0Yl_yO64IwlvBgzMu9EBKr9gg6y8QE55gu2PfTns,2783
+qulab/visualization/qdat.py,sha256=HubXFu4nfcA7iUzghJGle1C86G6221hicLR0b-GqhKQ,5887
+qulab/visualization/widgets.py,sha256=HcYwdhDtLreJiYaZuN3LfofjJmZcLwjMfP5aasebgDo,3266
+QuLab-2.0.1.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
+QuLab-2.0.1.dist-info/METADATA,sha256=NI3Uarm6V21L_ZOfXyn-HEQDCu_l_GNfOCKmE33Wm5c,3480
+QuLab-2.0.1.dist-info/WHEEL,sha256=lO6CqtLHCAi38X3Es1a4R1lAjZFvN010IMRCFo2S7Mc,102
+QuLab-2.0.1.dist-info/entry_points.txt,sha256=ohBzutEnQimP_BZWiuXdSliu4QAYSHHcN0PZD8c7ZCY,46
+QuLab-2.0.1.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+QuLab-2.0.1.dist-info/RECORD,,

QuLab-2.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: false
+Tag: cp310-cp310-win_amd64
+

QuLab-2.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qulab = qulab.__main__:main

QuLab-2.0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+qulab

qulab/__init__.py

@@ -0,0 +1 @@
+from .version import __version__

qulab/__main__.py

@@ -0,0 +1,24 @@
+import click
+
+from .monitor.__main__ import main as monitor
+from .sys.net.cli import dht
+from .visualization.__main__ import plot
+
+
+@click.group()
+def main():
+    pass
+
+
+@main.command()
+def hello():
+    """Print hello world."""
+    click.echo('hello, world')
+
+
+main.add_command(monitor)
+main.add_command(plot)
+main.add_command(dht)
+
+if __name__ == '__main__':
+    main()

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()