QuLab 2.0.1__cp310-cp310-macosx_11_0_x86_64.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=HnWr_0eErzaJUkjeTpeR7-l5FASfYK-h0VtqQI-eVoc,371
+qulab/fun.cpython-310-darwin.so,sha256=-fPL-Qi5PVXRqQ9-rUlYIGLeDU5OqNUB-n_AzZSb4M8,78416
+qulab/version.py,sha256=pMl7p0vBanIg04EfboBE80RyG_KP7M0m9V3-qTl0YLQ,21
+qulab/monitor/__init__.py,sha256=nTHelnDpxRS_fl_B38TsN0njgq8eVTEz9IAnN3NbDlM,42
+qulab/monitor/__main__.py,sha256=w3yUcqq195LzSnXTkQcuC1RSFRhy4oQ_PEBmucXguME,97
+qulab/monitor/config.py,sha256=fQ5JcsMApKc1UwANEnIvbDQZl8uYW0tle92SaYtX9lI,744
+qulab/monitor/dataset.py,sha256=C4wZU-XqYHY1ysvUGSF5958M_GANrXW-f1SHnruHJno,2455
+qulab/monitor/event_queue.py,sha256=o66jOTKJmJibt-bhYFjk5p_rExxu-hdoR_BfR8PMN3I,1823
+qulab/monitor/mainwindow.py,sha256=Bme7YKg2LQSpRH6cg8rcFhdnxUU_d_F4b6TIvPVAbx4,7799
+qulab/monitor/monitor.py,sha256=7E4bnTsO6qC85fs2ONrccGHfaYKv7SW74mtXzv6QjVc,2305
+qulab/monitor/ploter.py,sha256=CbiIjmohgtwDDTVeGzhXEGVo3XjytMdhLwU9VUkg9vo,3601
+qulab/monitor/qt_compat.py,sha256=OK71_JSO_iyXjRIKHANmaK4Lx4bILUzmXI-mwKg3QeI,788
+qulab/monitor/toolbar.py,sha256=WEag6cxAtEsOLL14XvM7pSE56EA3MO188_JuprNjdBs,7948
+qulab/scan/__init__.py,sha256=yT_L9Rdr9lwxds-uq-sC_lhnTQxJgIkSzQkiX9PYmug,216
+qulab/scan/base.py,sha256=SAmv-QRPHcN_FlfKeMykbBatm5Qo5DS76PFt5h2xtWY,17143
+qulab/scan/dataset.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/scan/expression.py,sha256=J0F7jFyCkMKcHieT5ok6alivjrnHXPqQ0Xil5czGDuI,14781
+qulab/scan/optimize.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/scan/scanner.py,sha256=H5wXarVeJab6pNVfLEWB6jCmpeIdpUu6igR9vlaQ-wc,7802
+qulab/scan/transforms.py,sha256=ReUuG57B_1GEgOwZZaxYbOTappG7yY9ERvagc2v48Pg,252
+qulab/scan/utils.py,sha256=2bj7ggTNTK5LXwBDi8w7IzFqFjchoE6EhgSASC0fpDQ,1024
+qulab/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/storage/__main__.py,sha256=3emxxRry8BB0m8hUZvJ_oBqkPy7ksV7flHB_KEDXZuI,1692
+qulab/storage/base_dataset.py,sha256=4aKhqBNdZfdlm_z1Qy5dv0HrvgpvMdy8pbyfua8uE-4,11865
+qulab/storage/chunk.py,sha256=dtck2Pem7OYYX3TYlnWwfqrgXSmkLhi0nN_ElbuS-c8,1701
+qulab/storage/dataset.py,sha256=Q9asJxNwYNcmu7sSqsAdAntYIre9b4dGIiFnt1O-KI4,4655
+qulab/storage/file.py,sha256=KAaXFI1SKdcCVWjopVqYaWU4WZgZU9Oh2epdqH1ADPw,8343
+qulab/storage/storage.py,sha256=qRyR-5zRRx84DfsifozlYKMRj8bykwRyF7TW8oyFmwk,2561
+qulab/storage/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/storage/backend/redis.py,sha256=hNaPP0V1BSWbUcx4AxOhEXiR83c_BZqeVzeOYkb8-zM,5202
+qulab/storage/models/__init__.py,sha256=DkKzQF7tYd1WL1gGPuCThBcGfpnCuZ_PTLrqV3M_EJ0,586
+qulab/storage/models/base.py,sha256=QLXiTRCPcg28BCFxBHexAxdNLjh2ONkzgNavoFOBW9s,114
+qulab/storage/models/config.py,sha256=Mxk0-YcK0WgA-7-2oIuDMAeBaUECzj-3_oPvgF7gYtE,689
+qulab/storage/models/file.py,sha256=1Rypz1QSco6drBCiR_BS6Oy0ifOapBIeNEm0uDqqxBk,2716
+qulab/storage/models/ipy.py,sha256=uYBeqWsOxxCWUsDpnwhxugh6C9OuH92OrChlLj0gddk,1574
+qulab/storage/models/models.py,sha256=JUqtvk8ywulkcFL38WfTviuVOcdvSGakZYJS7jAPNig,2879
+qulab/storage/models/record.py,sha256=L0k531bGF9JN-GLv3hG87tB7k0kuSBkEeC9vi6_qywE,4970
+qulab/storage/models/report.py,sha256=j9ByrVoue-rwaXcnfTzVOSf1xDJdlZJq666agF0AZRY,798
+qulab/storage/models/tag.py,sha256=c3cTxpJUoG9L6xyDvVuagYVhB32amzbkBOmVeRIZ5Zo,2339
+qulab/sys/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/sys/chat.py,sha256=DlFLP_gbVyL8fDUyad6Xu8sjQCZJauLIvF31mj5BtMs,22449
+qulab/sys/ipy_events.py,sha256=qvsqs7-CYQ-P4WtSe9UUZZ0tC88XxPMd9DM4LJALgEk,2889
+qulab/sys/progress.py,sha256=Tk1B96_1QrlI4yU0cyZlf2wVsF238DjQGqXJVG2j4t0,5350
+qulab/sys/device/__init__.py,sha256=bDqJrYQJx8YR4u_CYvJPpIBr6whP7pVnxnROTHk_yhA,149
+qulab/sys/device/basedevice.py,sha256=iqyX2SQLb7aRWNE5Uj2yHkFOLqVrX2I1N-xubTDB5tQ,6423
+qulab/sys/device/loader.py,sha256=AL0rNF4UZ-CUHoF8FNtT_ZGLwySvz7SDPsKALaJS8po,2501
+qulab/sys/device/utils.py,sha256=H9TvMqHZABhFdIah4uT0x9FvQ6ZPwbvw-wCnWTy4rfo,1564
+qulab/sys/drivers/FakeInstrument.py,sha256=kwIXN-dHmvGYBinmcCLxUQKm0ENiJpsMwgQIYNLDS2k,1867
+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=p85DtmVy3cna3Da07boau77el2Cnym5-mKGF4xCJSy4,4959
+qulab/sys/net/cli.py,sha256=dm-JxbgZgFH2P_5Zu3kSrLzy2U_VRLswkvE1d3xGp0w,5690
+qulab/sys/net/dhcp.py,sha256=gT5ehyvwW3y8E5u_DnYRd5I0KaddonmQJFVhlIS2yxM,23509
+qulab/sys/net/dhcpd.py,sha256=pNC47i-hu8HTzCrKU0PatL3AbgEqe1ovmpLPwNoZLa8,5322
+qulab/sys/net/kad.py,sha256=gGYb9cXbAdbYhubQdCRqOGigllBy0kSUp4z3_f3AWz0,38981
+qulab/sys/net/kcp.py,sha256=oFyiosQ1o0qeVA9hODIYEZtJj4HN1aNLGVP6vbxouMs,5761
+qulab/sys/net/nginx.py,sha256=QAQthr_Dux7xRpgqeY6BVxxre4dg0WJITztSk8Fn-jU,4964
+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=djK44hYVMixF2Y-lAXDGHlyyCmYGw7EJjB3I0ttejok,2567
+qulab/sys/rpc/msgpack.py,sha256=s9mbPIkQktO1FiSAuE6ymM_1w8rIERA0gMm5GQkT7z8,35327
+qulab/sys/rpc/msgpack.pyi,sha256=3dJgISPCTEBo65VaoGjcFkdLijPx6zJtKqcZiS9bcaE,1274
+qulab/sys/rpc/rpc.py,sha256=9ZwzC79FgmbHXbO1Gjg4z0wZgHLDziTwVuS2aZpLJAk,11979
+qulab/sys/rpc/serialize.py,sha256=0SR1me02mao2JwWR3rdjUIcOzh1m1JFb7fLEaw_q-pE,3355
+qulab/sys/rpc/server.py,sha256=e3R0gwOHpLEkSp7Tb43FMSDvqSG-pjrkskdISKQRseE,713
+qulab/sys/rpc/socket.py,sha256=e3R0gwOHpLEkSp7Tb43FMSDvqSG-pjrkskdISKQRseE,713
+qulab/sys/rpc/utils.py,sha256=6YGFOkY7o09lkA_I1FIP9_1Up3k2F1KOkftvu0_8lxo,594
+qulab/sys/rpc/worker.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+qulab/visualization/__init__.py,sha256=26cuHt3QIJXUb3VaMxlJx3IQTOUVJFKlYBZr7WMP53M,6129
+qulab/visualization/__main__.py,sha256=9zKK3yZFy0leU40ou6BpRC1Fsetfc1gjjFzIZYIwP6Y,1639
+qulab/visualization/_autoplot.py,sha256=p4jzsJFgtOhnU0iuZJvjTT2ar6fvGd9VmxBr5dx1JC8,13777
+qulab/visualization/plot_layout.py,sha256=clNw9QjE_kVNpIIx2Ob4YhAz2fucPGMuzkoIrOJo_Y8,13533
+qulab/visualization/plot_seq.py,sha256=lphYF4VhkEdc_wWr1kFBwrx2yujkyFPFaJ3pjr61awI,2693
+qulab/visualization/qdat.py,sha256=ZeevBYWkzbww4xZnsjHhw7wRorJCBzbG0iEu-XQB4EA,5735
+qulab/visualization/widgets.py,sha256=6KkiTyQ8J-ei70LbPQZAK35wjktY47w2IveOa682ftA,3180
+QuLab-2.0.1.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
+QuLab-2.0.1.dist-info/METADATA,sha256=9lh5a31NtQa3tADAUrr94sSw38Mzza_1BSzEkHJVtPY,3385
+QuLab-2.0.1.dist-info/WHEEL,sha256=v2akoWUNGxyk4Dpga8gpYszagodl-xQddd16moZ4Utw,111
+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-macosx_11_0_x86_64
+

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