QuLab 2.11.15__py3-none-any.whl → 2.12.0__py3-none-any.whl

qulab/__init__.py

@@ -1,10 +1,11 @@
 from qlisp import (CR, CX, CZ, SWAP, A, B, BellPhiM, BellPhiP, BellPsiM,
                    BellPsiP, H, S, Sdag, SQiSWAP, T, Tdag, U, Unitary2Angles,
-                   applySeq, draw, fSim, iSWAP, kak_decomposition, kak_vector,
-                   make_immutable, measure, phiminus, phiplus, psiminus,
-                   psiplus, regesterGateMatrix, rfUnitary, seq2mat, sigmaI,
-                   sigmaM, sigmaP, sigmaX, sigmaY, sigmaZ,
-                   synchronize_global_phase)
+                   applySeq)
+from qlisp import draw as draw_qlisp
+from qlisp import (fSim, iSWAP, kak_decomposition, kak_vector, make_immutable,
+                   measure, phiminus, phiplus, psiminus, psiplus,
+                   regesterGateMatrix, rfUnitary, seq2mat, sigmaI, sigmaM,
+                   sigmaP, sigmaX, sigmaY, sigmaZ, synchronize_global_phase)
 from qlispc import (COMMAND, FREE, NOTSET, PUSH, READ, SYNC, TRIG, WRITE,
                     compile, get_arch, libraries, mapping_qubits,
                     register_arch)
@@ -30,4 +31,6 @@ from .executor.template import VAR
 from .executor.utils import debug_analyze
 from .scan import Scan, get_record, load_record, lookup, lookup_list
 from .version import __version__
-from .visualization import autoplot
+from .visualization import autoplot, plot_mat
+from .visualization.plot_layout import draw as draw_layout
+from .visualization.plot_layout import fill_layout

qulab/executor/registry.py

@@ -2,7 +2,7 @@ import copy
 import importlib
 import os
 import sys
-from typing import Any
+from typing import Any, Callable, cast
 
 from ..cli.config import get_config_value
 from .storage import Report, save_item
@@ -66,7 +66,7 @@ def _export_config() -> dict:
     return parameters
 
 
-def _clear_config():
+def _clear_config() -> None:
     import pickle
 
     try:
@@ -142,13 +142,13 @@ def set_config_api(query_method,
 
 
 def _init():
-    code = get_config_value("code", str, default=None)
+    code = cast(str, get_config_value("code", str, default=None))
     if code is not None:
         code = os.path.expanduser(code)
         if code not in sys.path:
             sys.path.insert(0, code)
 
-    api = get_config_value('api', str, None)
+    api = cast(str, get_config_value('api', str, None))
     if api is not None:
         api = importlib.import_module(api)
         set_config_api(api.query_config, api.update_config, api.delete_config,
@@ -283,29 +283,34 @@ class RegistrySnapshot:
 class Registry():
 
     def __init__(self):
-        self.api = (query_config, update_config, delete_config, export_config,
-                    clear_config)
+        self.api: dict[str, Callable] = {
+            'query': query_config,
+            'update': update_config,
+            'delete': delete_config,
+            'export': export_config,
+            'clear': clear_config,  # type: ignore
+        }
 
     def query(self, key: str) -> Any:
-        return self.api[0](key)
+        return self.api['query'](key)
 
     def get(self, key: str) -> Any:
         return self.query(key)
 
     def export(self) -> dict[str, dict[str, Any]]:
-        return self.api[3]()
+        return self.api['export']()
 
     def set(self, key: str, value: Any):
-        return self.api[1]({key: value})
+        return self.api['update']({key: value})
 
     def delete(self, key: str):
-        return self.api[2](key)
+        return self.api['delete'](key)
 
-    def clear(self):
-        return self.api[4]()
+    def clear(self) -> None:
+        return self.api['clear']()
 
     def update(self, parameters: dict[str, Any]):
-        return self.api[1](parameters)
+        return self.api['update'](parameters)
 
     def snapshot(self) -> RegistrySnapshot:
         return RegistrySnapshot(self.export())

qulab/executor/template.py

@@ -6,7 +6,7 @@ import pickle
 import re
 import string
 import textwrap
-from typing import Any
+from typing import Any, cast
 
 _notset = object()
 
@@ -14,8 +14,7 @@ _notset = object()
 def VAR(name: str, /, *, default: Any = _notset) -> Any:
     if default is _notset:
         raise TemplateKeyError(
-            f"The variable '{name}' is not provided in mapping."
-        )
+            f"The variable '{name}' is not provided in mapping.")
     else:
         return default
 
@@ -60,20 +59,22 @@ class TemplateVarExtractor(ast.NodeVisitor):
     def visit_Constant(self, node):
         if isinstance(node.value, str):
             self._process_string(node.value, node.lineno, node.col_offset,
-                                 node.end_lineno, node.end_col_offset)
+                                 cast(int, node.end_lineno),
+                                 cast(int, node.end_col_offset))
 
     def visit_JoinedStr(self, node):
         for value in node.values:
             if isinstance(value, ast.Constant) and isinstance(
                     value.value, str):
                 self._process_string(value.value, value.lineno,
-                                     value.col_offset, value.end_lineno,
-                                     value.end_col_offset)
+                                     value.col_offset,
+                                     cast(int, value.end_lineno),
+                                     cast(int, value.end_col_offset))
         self.generic_visit(node)
 
     def visit_FunctionDef(self, node):
         if node.name == 'VAR':
-            self.var_func_def = (node.lineno, node.end_lineno)
+            self.var_func_def = (node.lineno, cast(int, node.end_lineno))
         self.generic_visit(node)
 
     def visit_Call(self, node):
@@ -81,15 +82,11 @@ class TemplateVarExtractor(ast.NodeVisitor):
             arg = node.args[0]
             if not isinstance(arg, ast.Constant) or not isinstance(
                     arg.value, str):
-                raise SyntaxError(
-                    f"Argument of VAR function must be a string."
-                    f" {self.fname}:{node.lineno}"
-                )
+                raise SyntaxError(f"Argument of VAR function must be a string."
+                                  f" {self.fname}:{node.lineno}")
             if len(node.args) != 1:
-                raise SyntaxError(
-                    f"VAR function only accept one argument."
-                    f" {self.fname}:{node.lineno}"
-                )
+                raise SyntaxError(f"VAR function only accept one argument."
+                                  f" {self.fname}:{node.lineno}")
             default = _notset
             for k in node.keywords:
                 if k.arg == 'default':
@@ -105,8 +102,7 @@ class TemplateVarExtractor(ast.NodeVisitor):
                 else:
                     raise SyntaxError(
                         f"VAR function only accept keyword argument 'default'."
-                        f" {self.fname}:{node.lineno}"
-                    )
+                        f" {self.fname}:{node.lineno}")
 
             if default is _notset:
                 # new_node = ast.Subscript(value=ast.Name(id="__VAR",
@@ -116,8 +112,7 @@ class TemplateVarExtractor(ast.NodeVisitor):
                 if arg.value not in self.mapping:
                     raise TemplateKeyError(
                         f"The variable '{arg.value}' is not provided in mapping."
-                        f" {self.fname}:{node.lineno}"
-                    )
+                        f" {self.fname}:{node.lineno}")
                 self.replacements[(node.lineno, node.end_lineno,
                                    node.col_offset,
                                    node.end_col_offset)] = ('VAR', arg.value,
@@ -174,7 +169,7 @@ class TemplateVarExtractor(ast.NodeVisitor):
 
 
 def inject_mapping(source: str, mapping: dict[str, Any],
-                   fname: str) -> list[tuple[str, int]]:
+                   fname: str) -> tuple[str, str]:
     hash_str, mapping_code = encode_mapping(mapping)
 
     tree = ast.parse(source)

qulab/monitor/dataset.py

@@ -10,7 +10,7 @@ contain multiple named columns of numerical data.
 """
 
 from collections import defaultdict, deque
-from typing import Union, Sequence
+from typing import Union, Sequence, cast
 
 from .config import ROLL_BUFFER_SIZE
 
@@ -126,10 +126,10 @@ class Dataset:
             return
         try:
             # Test if dataframe is a list of lists (trace data)
-            iter(dataframe[0])
-            self._append_traces(dataframe)
+            iter(dataframe[0])  # type: ignore
+            self._append_traces(cast(Sequence[Sequence[Number]], dataframe))
         except TypeError:
-            self._append_points(dataframe)
+            self._append_points(cast(Sequence[Number], dataframe))
 
     def roll(self) -> None:
         """

qulab/monitor/event_queue.py

@@ -70,14 +70,16 @@ class EventQueue:
                 if not isinstance(event, tuple):
                     raise ValueError("Queue event must be a tuple")
                 if len(event) != 2:
-                    raise ValueError("Queue event must contain exactly two elements (command, data)")
-                
+                    raise ValueError(
+                        "Queue event must contain exactly two elements (command, data)"
+                    )
+
                 command, data = event
                 if not isinstance(command, str):
                     raise ValueError("Command must be a string")
-                
+
                 self.handle(command, data)
-                
+
             except (ValueError, AssertionError) as error:
                 warnings.warn(f"Invalid event format: {error}")
                 continue
@@ -103,25 +105,25 @@ class EventQueue:
             case "PN":  # Set point data column names
                 self.point_dataset.set_column_names(data)
                 self.toolbar.refresh_comb()
-                
+
             case "TN":  # Set trace data column names
                 self.trace_dataset.set_column_names(data)
                 self.toolbar.refresh_comb()
-                
+
             case "PD":  # Append point data
                 self.point_dataset.append(data)
-                
+
             case "TD":  # Append trace data
                 self.trace_dataset.append(data)
-                
+
             case "ROLL":  # Create new data frame
                 self.point_dataset.roll()
-                
+
             case "PXY":  # Update point plot configuration
                 self.toolbar.set_point_text(data)
-                
+
             case "TXY":  # Update trace plot configuration
                 self.toolbar.set_trace_text(data)
-                
+
             case _:
                 warnings.warn(f"Unknown command: {command}")

qulab/monitor/mainwindow.py

@@ -7,15 +7,16 @@ interactive features like axis linking and data transformation.
 """
 
 from multiprocessing import Queue
-from typing import Literal
+from typing import Literal, cast
 
-from .config import TRANSFORMS, ROLL_INDICES, STYLE
+from .config import ROLL_INDICES, STYLE, TRANSFORMS
 from .dataset import Dataset
 from .event_queue import EventQueue
 from .ploter import PlotWidget
-from .qt_compat import (BottomDockWidgetArea, QtCore, QtWidgets,
-                        ScrollBarAlwaysOff, ScrollBarAlwaysOn,
-                        TopDockWidgetArea)
+from .qt_compat import QtCore  # type: ignore
+from .qt_compat import QtWidgets  # type: ignore
+from .qt_compat import (BottomDockWidgetArea, ScrollBarAlwaysOff,
+                        ScrollBarAlwaysOn, TopDockWidgetArea)
 from .toolbar import ToolBar
 
 
@@ -50,13 +51,13 @@ class MainWindow(QtWidgets.QMainWindow):
         self.plot_minimum_height = plot_minimum_height
         self.plot_widgets: list[PlotWidget] = []
         self.plot_colors = plot_colors
-        
+
         # Initialize components
         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.trace_data_box)
 
         self.init_ui()
 
@@ -70,7 +71,7 @@ class MainWindow(QtWidgets.QMainWindow):
         self.setStyleSheet(STYLE)
         self.setMinimumHeight(500)
         self.setMinimumWidth(700)
-        
+
         # Create scroll area
         self.scroll = QtWidgets.QScrollArea()
         self.widget = QtWidgets.QWidget()
@@ -100,7 +101,7 @@ class MainWindow(QtWidgets.QMainWindow):
     @property
     def mode(self) -> Literal["P", "T"]:
         """Current plotting mode (Points or Traces)."""
-        return self.toolbar.mode
+        return cast(Literal["P", "T"], self.toolbar.mode)
 
     @property
     def dataset(self) -> Dataset:
@@ -119,7 +120,7 @@ class MainWindow(QtWidgets.QMainWindow):
         plot_count = len(self.plot_widgets)
         plot_widget = PlotWidget(self.plot_minimum_height, self.plot_colors)
         self.plot_widgets.append(plot_widget)
-        
+
         grid_row = plot_count // self.num_columns
         grid_col = plot_count % self.num_columns
         self.layout.addWidget(plot_widget, grid_row + 1, grid_col)
@@ -175,9 +176,9 @@ class MainWindow(QtWidgets.QMainWindow):
 
     def do_link(self):
         """Link plots that share the same X or Y axis."""
-        same_x_axis = {}
+        same_x_axis: dict[str, list[int]] = {}
         xy_pairs = self.toolbar.xypairs
-        
+
         # Group plots by X axis
         for idx, (x_name, y_name) in enumerate(xy_pairs):
             if x_name not in same_x_axis:
@@ -250,19 +251,20 @@ class MainWindow(QtWidgets.QMainWindow):
         if self.dataset.dirty or self.toolbar.xyfm_dirty or needs_rescale:
             self.dataset.dirty = False
             self.toolbar.xyfm_dirty = False
-            
+
             # Update plot data
             for plot_widget in self.plot_widgets:
-                x_transform = TRANSFORMS[self.toolbar.fx]
-                y_transform = TRANSFORMS[self.toolbar.fy]
-                
+                x_transform = TRANSFORMS[cast(str, self.toolbar.fx)]
+                y_transform = TRANSFORMS[cast(str, self.toolbar.fy)]
+
                 for idx in ROLL_INDICES:
-                    x_data, y_data = self.dataset.get_data(idx, plot_widget.x_name, plot_widget.y_name)
+                    x_data, y_data = self.dataset.get_data(
+                        idx, plot_widget.x_name, plot_widget.y_name)
                     data_length = min(len(x_data), len(y_data))
                     x_data = x_transform(x_data[:data_length], 0)
                     y_data = y_transform(y_data[:data_length], 0)
                     plot_widget.set_data(idx, x_data, y_data)
-                    
+
                 plot_widget.update()
                 if needs_rescale:
                     plot_widget.auto_range()

qulab/monitor/monitor.py

@@ -11,6 +11,8 @@ Classes:
 
 import multiprocessing as mp
 import sys
+from typing import cast
+
 import zmq
 
 # try:
@@ -33,10 +35,11 @@ def main(data_queue: mp.Queue,
         plot_colors: List of RGB color tuples for plot lines
     """
     from .mainwindow import MainWindow
-    from .qt_compat import QtWidgets
+    from .qt_compat import QtWidgets  # type: ignore
 
     app = QtWidgets.QApplication(sys.argv)
-    main_window = MainWindow(data_queue, num_columns, minimum_height, plot_colors)
+    main_window = MainWindow(data_queue, num_columns, minimum_height,
+                             plot_colors)
     sys.exit(app.exec())
 
 
@@ -71,8 +74,8 @@ class MonitorUI:
             return
         self.queue = mp.Queue(20)
         self.process = mp.Process(target=main,
-                                args=(self.queue, self.number_of_columns,
-                                     self.minimum_height, self.colors))
+                                  args=(self.queue, self.number_of_columns,
+                                        self.minimum_height, self.colors))
         self.process.start()
 
     def _put(self, message: tuple) -> None:
@@ -119,18 +122,19 @@ class MonitorUI:
 
     def is_alive(self) -> bool:
         """Check if the monitoring process is running."""
-        return self.process.is_alive()
+        return self.process is not None and self.process.is_alive()
 
     def __del__(self):
         """Clean up resources when the Monitor object is deleted."""
         try:
-            self.process.kill()
+            cast(mp.Process, self.process).kill()
         except:
             pass
 
 
 class Monitor:
-    def __init__(self, address: str="127.0.0.1", port: int=5555):
+
+    def __init__(self, address: str = "127.0.0.1", port: int = 5555):
         self.context = zmq.Context()
         self.socket = self.context.socket(zmq.REQ)
         self.socket.connect(f"tcp://{address}:{port}")
@@ -174,7 +178,11 @@ class Monitor:
 
 
 class MonitorServer:
-    def __init__(self, address: str="*", port: int=5555, number_of_columns: int = 4,
+
+    def __init__(self,
+                 address: str = "*",
+                 port: int = 5555,
+                 number_of_columns: int = 4,
                  minimum_height: int = 400,
                  colors: list[tuple[int, int, int]] = []):
         self.address = address
@@ -189,8 +197,9 @@ class MonitorServer:
     def _run(self):
         try:
             # Create Monitor instance in the child process
-            self.monitor = MonitorUI(self.number_of_columns, self.minimum_height, self.colors)
-            
+            self.monitor = MonitorUI(self.number_of_columns,
+                                     self.minimum_height, self.colors)
+
             # Create ZMQ context and socket in the child process
             self.context = zmq.Context()
             self.socket = self.context.socket(zmq.REP)
@@ -253,12 +262,13 @@ def get_monitor(auto_open: bool = True) -> MonitorUI:
     if auto_open and (_monitor is None or not _monitor.is_alive()):
         _monitor = MonitorUI()
 
-    return _monitor
+    return cast(MonitorUI, _monitor)
 
 
 if __name__ == "__main__":
     # Example usage and testing code
     import time
+
     import numpy as np
 
     # Example 1: Using Monitor directly
@@ -290,11 +300,11 @@ if __name__ == "__main__":
     def run_client():
         client = Monitor("127.0.0.1", 5555)
         time.sleep(1)  # Wait for server to start
-        
+
         client.set_column_names("index", "H", "S")
         client.set_plots("(index,H);(index,S)")
         client.roll()
-        
+
         for i in range(100):
             client.add_point(i, np.random.randn(), np.sin(i / 20))
             time.sleep(0.2)

qulab/monitor/ploter.py

@@ -6,18 +6,18 @@ data visualization. It includes features like auto-ranging, mouse interaction
 for data selection, and clipboard integration.
 """
 
-from .config import (COLOR_SELECTED, COLOR_UNSELECTED, SYMBOL_SIZES,
-                    DEFAULT_COLORS, ROLL_INDICES, LINE_WIDTHS)
-from .qt_compat import QtWidgets
+from .config import (COLOR_SELECTED, COLOR_UNSELECTED, DEFAULT_COLORS,
+                     LINE_WIDTHS, ROLL_INDICES, SYMBOL_SIZES)
+from .qt_compat import QtWidgets  # type: ignore
 
 # the plotting widget
 try:
-    import pyqtgraph as pg
+    import pyqtgraph as pg  # type: ignore
 except ImportError:
     raise ImportError("Please install pyqtgraph first")
 
 try:
-    import pyperclip as pc
+    import pyperclip as pc  # type: ignore
     HAS_CLIPBOARD = True
 except ImportError:
     HAS_CLIPBOARD = False
@@ -122,14 +122,16 @@ class PlotWidget(pg.PlotWidget):
     def mousePressEvent(self, event):
         """Handle mouse press events for data selection."""
         if event.button() == 4 and HAS_CLIPBOARD:
-            self.clip_pos_start = self.plotItem.vb.mapSceneToView(event.pos()).x()
+            self.clip_pos_start = self.plotItem.vb.mapSceneToView(
+                event.pos()).x()
         else:
             super().mousePressEvent(event)
 
     def mouseReleaseEvent(self, event):
         """Handle mouse release events and copy selected data to clipboard."""
         if event.button() == 4 and HAS_CLIPBOARD:
-            self.clip_pos_end = self.plotItem.vb.mapSceneToView(event.pos()).x()
+            self.clip_pos_end = self.plotItem.vb.mapSceneToView(
+                event.pos()).x()
             if self.range_select:
                 pc.copy(f"{self.clip_pos_start},{self.clip_pos_end}")
             else:

qulab/monitor/qt_compat.py

@@ -13,7 +13,8 @@ The module exports the following constants:
 - TopDockWidgetArea: Top dock widget area constant
 """
 
-from matplotlib.backends.qt_compat import QT_API, QtCore, QtWidgets
+from matplotlib.backends.qt_compat import (QT_API, QtCore,  # type: ignore
+                                           QtWidgets)       # type: ignore
 
 # Define Qt constants based on the Qt binding being used
 if QT_API in ['PySide6', 'PyQt6']:

qulab/monitor/toolbar.py

@@ -14,7 +14,7 @@ import re
 from typing import Callable, List, Tuple
 
 from .config import STYLE, TRANSFORM_NAMES
-from .qt_compat import AlignRight, QtWidgets
+from .qt_compat import AlignRight, QtWidgets  # type: ignore
 
 
 def matched_xy_pairs(patterns: str, column_names: list[str]) -> list[tuple[str, str]]:
@@ -28,11 +28,11 @@ def matched_xy_pairs(patterns: str, column_names: list[str]) -> list[tuple[str,
     Returns:
         List of matched (x, y) column name pairs
     """
-    patterns = patterns.replace(" ", "").split(";")
+    pattern_list = patterns.replace(" ", "").split(";")
     pairs = []
     for x, y in itertools.product(column_names, repeat=2):
         test = f"{x},{y}"
-        for pattern in patterns:
+        for pattern in pattern_list:
             r = re.match(pattern, test)
             if r and r.group(0) == test:
                 pairs.append((x, y))

qulab/version.py

@@ -1 +1 @@
-__version__ = "2.11.15"
+__version__ = "2.12.0"

qulab/visualization/_autoplot.py

@@ -114,7 +114,7 @@ class MyLogFormatter(EngFormatter):
             return super().format_eng(10.0**x)
 
 
-def imshow_logx(x, y, z, x_unit=None, ax=None, **kwargs):
+def imshow_logx(x, y, z, x_unit: str | None = None, ax=None, **kwargs):
     if ax is None:
         ax = plt.gca()
 
@@ -127,13 +127,13 @@ def imshow_logx(x, y, z, x_unit=None, ax=None, **kwargs):
     img = ax.imshow(z, extent=extent, **kwargs)
 
     ax.set_xticks(major_ticks, minor=False)
-    ax.xaxis.set_major_formatter(MyLogFormatter(x_unit))
+    ax.xaxis.set_major_formatter(MyLogFormatter(x_unit))  # type: ignore
     ax.set_xticks(minor_ticks, minor=True)
 
     return img
 
 
-def imshow_logy(x, y, z, y_unit=None, ax=None, **kwargs):
+def imshow_logy(x, y, z, y_unit: str | None = None, ax=None, **kwargs):
     if ax is None:
         ax = plt.gca()
 
@@ -146,13 +146,13 @@ def imshow_logy(x, y, z, y_unit=None, ax=None, **kwargs):
     img = ax.imshow(z, extent=extent, **kwargs)
 
     ax.set_yticks(major_ticks, minor=False)
-    ax.yaxis.set_major_formatter(MyLogFormatter(y_unit))
+    ax.yaxis.set_major_formatter(MyLogFormatter(y_unit))  # type: ignore
     ax.set_yticks(minor_ticks, minor=True)
 
     return img
 
 
-def imshow_loglog(x, y, z, x_unit=None, y_unit=None, ax=None, **kwargs):
+def imshow_loglog(x, y, z, x_unit: str | None = None, y_unit: str | None = None, ax=None, **kwargs):
     if ax is None:
         ax = plt.gca()
 
@@ -166,11 +166,11 @@ def imshow_loglog(x, y, z, x_unit=None, y_unit=None, ax=None, **kwargs):
     img = ax.imshow(z, extent=extent, **kwargs)
 
     ax.set_xticks(x_major_ticks, minor=False)
-    ax.xaxis.set_major_formatter(MyLogFormatter(x_unit))
+    ax.xaxis.set_major_formatter(MyLogFormatter(x_unit))  # type: ignore
     ax.set_xticks(x_minor_ticks, minor=True)
 
     ax.set_yticks(y_major_ticks, minor=False)
-    ax.yaxis.set_major_formatter(MyLogFormatter(y_unit))
+    ax.yaxis.set_major_formatter(MyLogFormatter(y_unit))  # type: ignore
     ax.set_yticks(y_minor_ticks, minor=True)
 
     return img
@@ -186,9 +186,9 @@ def plot_lines(x,
                y_unit,
                z_unit,
                ax,
-               xscale='linear',
-               yscale='linear',
-               zscale='linear',
+               xscale: str = 'linear',
+               yscale: str = 'linear',
+               zscale: str = 'linear',
                index=None,
                **kwds):
     z = np.asarray(z)
@@ -230,9 +230,9 @@ def plot_img(x,
              z_unit,
              fig,
              ax,
-             xscale='linear',
-             yscale='linear',
-             zscale='linear',
+             xscale: str = 'linear',
+             yscale: str = 'linear',
+             zscale: str = 'linear',
              resolution=None,
              **kwds):
     kwds.setdefault('origin', 'lower')
@@ -325,9 +325,9 @@ def plot_scatter(x,
                  z_unit,
                  fig,
                  ax,
-                 xscale='linear',
-                 yscale='linear',
-                 zscale='linear',
+                 xscale: str = 'linear',
+                 yscale: str = 'linear',
+                 zscale: str = 'linear',
                  **kwds):
     if np.any(np.iscomplex(z)):
         s = np.abs(z)
@@ -356,9 +356,9 @@ def autoplot(x,
              fig=None,
              ax=None,
              index=None,
-             xscale='auto',
-             yscale='auto',
-             zscale='auto',
+             xscale: str = 'auto',
+             yscale: str = 'auto',
+             zscale: str = 'auto',
              max_lines=3,
              scatter_lim=1000,
              resolution=None,

qulab/visualization/plot_circ.py

@@ -33,13 +33,13 @@ def make_path(fx, fy, dfx, dfy, t):
 
 
 def plot_square(ax,
-                x=0,
-                y=0,
-                width=1,
-                hight=1,
+                x=0.0,
+                y=0.0,
+                width=1.0,
+                hight=1.0,
                 radius=0.2,
                 ls='-',
-                lw=2,
+                lw=2.0,
                 fc='none',
                 ec='black'):
     r = radius

qulab/visualization/plot_layout.py

@@ -1,5 +1,6 @@
 import functools
 import operator
+from typing import cast
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -53,6 +54,85 @@ def complete_layout(layout):
     return layout
 
 
+def read_xlsx_to_dict(filepath: str,
+                      key_col: int = 0,
+                      value_col: int = 4,
+                      sheet_name: str = 0) -> dict:
+    """
+    读取 .xlsx 文件，将第 key_col 列和第 value_col 列的值分别作为 key、value，返回一个字典。
+
+    :param filepath: Excel 文件路径
+    :param key_col: 用作字典键的列索引（0 表示第一列）
+    :param value_col: 用作字典值的列索引（0 表示第一列）
+    :param sheet_name: 要读取的 sheet 名称或索引，默认第一个 sheet
+    :return: { key: value, ... } 形式的字典
+    """
+    import pandas as pd
+
+    # 读取整个表格
+    # df = pd.read_excel(filepath, sheet_name=sheet_name, header=None)
+    df = pd.read_excel(filepath, sheet_name=sheet_name)
+
+    # 提取指定列，生成键值对并返回字典
+    keys = df.iloc[:, key_col]
+    values = df.iloc[:, value_col]
+    return dict(zip(keys, values))
+
+
+def load_layout_from_xlsx(qubit_info, coupler_info, pad_info):
+    """
+    从 .xlsx 文件中加载布局信息。
+
+    :param qubit_info: 量子比特信息文件路径
+    :param coupler_info: 耦合器信息文件路径
+    :param pad_info: 垫片信息文件路径
+    :return: 布局信息
+    """
+    import pandas as pd
+
+    _qubits = {}
+
+    qubit_pad = read_xlsx_to_dict(qubit_info, value_col=4)
+    coupler_pad = read_xlsx_to_dict(coupler_info, value_col=3)
+    pads = {
+        v: k
+        for k, v in qubit_pad.items()
+    } | {
+        v: k
+        for k, v in coupler_pad.items()
+    }
+    pad_info = read_xlsx_to_dict(pad_info, value_col=2)
+
+    lyt = {'qubits': {}, 'couplers': {}, 'feedlines': {}}
+
+    for pad, script in pad_info.items():
+        info = eval(script)
+        match info['style']:
+            case 'Q':
+                qubit = pads[pad]
+                lyt['qubits'][qubit] = {'pos': info['qb'], 'pad': pad}
+                _qubits[info['qb']] = qubit
+            case 'C':
+                coupler = pads[pad]
+                if 'cpl' in info:
+                    pos = tuple(info['cpl'])
+                else:
+                    pos = tuple(info['qb'])
+                lyt['couplers'][coupler] = {'qubits': pos, 'pad': pad}
+            case 'TL':
+                l = info['tl']
+                if f"T{l}" in lyt['feedlines']:
+                    lyt['feedlines'][f"T{l}"]['pads'].append(pad)
+                else:
+                    lyt['feedlines'][f"T{l}"] = {'pads': [pad]}
+
+    for coupler in lyt['couplers']:
+        qubits = lyt['couplers'][coupler]['qubits']
+        lyt['couplers'][coupler]['qubits'] = [_qubits[p] for p in qubits]
+
+    return complete_layout(lyt)
+
+
 def get_shared_coupler(layout, q1, q2):
     for c in layout['qubits'][q1]['couplers']:
         if q2 in layout['couplers'][c]['qubits']:
@@ -245,6 +325,10 @@ def _draw_coupler(ax, coupler, layout, q1, q2, pos1, pos2):
 
     text_rotation = 180 * np.arctan2(pos2[1] - pos1[1],
                                      pos2[0] - pos1[0]) / np.pi
+    if text_rotation > 90:
+        text_rotation -= 180
+    elif text_rotation < -90:
+        text_rotation += 180
 
     path = circle_link_path(pos1, pos2, r1, r2, width)
     plot_range(ax,
@@ -452,15 +536,19 @@ def fill_layout(layout,
     coupler_cmap = plt.get_cmap(coupler_cmap)
 
     if qubit_norm is None:
-        qubit_norm = get_norm(params,
-                              layout['qubits'].keys(),
-                              vmin=qubit_vmin,
-                              vmax=qubit_vmax)
+        qubit_norm = cast(
+            Normalize,
+            get_norm(params,
+                     layout['qubits'].keys(),
+                     vmin=qubit_vmin,
+                     vmax=qubit_vmax))
     if coupler_norm is None:
-        coupler_norm = get_norm(params,
-                                layout['couplers'].keys(),
-                                vmin=coupler_vmin,
-                                vmax=coupler_vmax)
+        coupler_norm = cast(
+            Normalize,
+            get_norm(params,
+                     layout['couplers'].keys(),
+                     vmin=coupler_vmin,
+                     vmax=coupler_vmax))
     layout['__colorbar__'] = {
         'coupler': {
             'cmap': coupler_cmap,

{qulab-2.11.15.dist-info → qulab-2.12.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: QuLab
-Version: 2.11.15
+Version: 2.12.0
 Summary: contral instruments and manage data
 Author-email: feihoo87 <feihoo87@gmail.com>
 Maintainer-email: feihoo87 <feihoo87@gmail.com>

{qulab-2.11.15.dist-info → qulab-2.12.0.dist-info}/RECORD

@@ -1,8 +1,8 @@
-qulab/__init__.py,sha256=hmf6R3jiM5NtJY1mSptogYnH5DMTR2dTzlXykqLxQzg,2027
+qulab/__init__.py,sha256=ijh3NWuSCU_KWRrPfddX4vfPcYPmvKs64vSTl9qd-SU,2178
 qulab/__main__.py,sha256=fjaRSL_uUjNIzBGNgjlGswb9TJ2VD5qnkZHW3hItrD4,68
 qulab/typing.py,sha256=vg62sGqxuD9CI5677ejlzAmf2fVdAESZCQjAE_xSxPg,69
 qulab/utils.py,sha256=B_8QdY9OMY7WU-F200v93BDJXJpQcKAHihnOXeEvv_w,3966
-qulab/version.py,sha256=Xwyp7A0xHh2GDh3MUxhzaH2tfp0EQ4tK8L1vQV9D1ow,23
+qulab/version.py,sha256=9qeMwbCMEAjH-vk_63Tak43katUwSOLexvq8N_IKi8c,22
 qulab/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/cli/commands.py,sha256=ywKmwbGNBCVASx8OsgrRttaLz9ogwY38ZdKj7I-tdJ4,813
 qulab/cli/config.py,sha256=Z-lePcDMeeQmwFpdfQHqZuaXTPhWUHN5KrlSqrya73Y,6324
@@ -11,21 +11,21 @@ qulab/executor/__init__.py,sha256=LosPzOMaljSZY1thy_Fxtbrgq7uubJszMABEB7oM7tU,10
 qulab/executor/analyze.py,sha256=VYTfiOYJe5gDbtGA4wOkrQhhu55iIrRVByx-gBLUUm4,5672
 qulab/executor/cli.py,sha256=fTB7V8xNCvpU8EMa__ysBvRCzruP-QFbXOyLpeTPx0E,25711
 qulab/executor/load.py,sha256=eMlzOrrn8GpbP3J3uY5JJ8iO7tL5B1DWP1z2qiGyNhU,20385
-qulab/executor/registry.py,sha256=CPY5PNTbE4Rw13Ucsq1wBk3fgvoSB3_J-iyRFdNNl0g,9044
+qulab/executor/registry.py,sha256=yWO6nJ1nMVve_HF5xzSd7QmZEIjoGvD_Txg73_f30gE,9279
 qulab/executor/schedule.py,sha256=cDFM_tIMvxHLxb-tBA6fEPF9u-4LcgnQDxbaquZIQKc,21727
 qulab/executor/storage.py,sha256=8K73KGLAVgchJdtd4rKHXkr1CQOJORWH-Gi57w8IYsw,21081
-qulab/executor/template.py,sha256=Fxou5lglaCnEhJTKDotFaRrWT4csAZIgmHz9EFbPnYs,10811
+qulab/executor/template.py,sha256=XyZKt2b0J-gSEA9mHoWmA7ADLWrUwOAL5oxYkX-UNg8,10837
 qulab/executor/utils.py,sha256=YSUEYjyYTJTjiJmd-l5GTEnSyD6bqEdNoWhivEAfGZA,7112
 qulab/monitor/__init__.py,sha256=FNYMIUr8ycRM4XmsAGpRK-A-SQsJZlcRWghXcGTgAi0,44
 qulab/monitor/__main__.py,sha256=Txy4d7vgVYUWwiHxX3uwtsi1ewde-MaiSC_K0ePoPiM,1372
 qulab/monitor/config.py,sha256=lMMRHy6wnVgMHiRMQqev5lj8mbF2g29TLrK82dwp_2k,1950
-qulab/monitor/dataset.py,sha256=9ctuod8SE0yRfWABC2dyosDHwjr0higR4lTP4n4usJk,6152
-qulab/monitor/event_queue.py,sha256=rfD9qC8miT96myBcfERJfzi7-wotzEiq2ld-4e277tk,4615
-qulab/monitor/mainwindow.py,sha256=c4anPDroq_ik8wbc300bgSmrnM9mcz2NxM-IaJKPkao,9969
-qulab/monitor/monitor.py,sha256=RwmjKJZVTyfDs_bYigh576zwUG_crgxKhbly2rWFFbE,9604
-qulab/monitor/ploter.py,sha256=Fl63M7kz9dcnmDYoXZxcvehd_oZRFpSofXEzRsVEDd8,4799
-qulab/monitor/qt_compat.py,sha256=f45fGhmHiHBxaFeaajRs1NnzFHH1qnXzU5Sgv6-s7MI,1648
-qulab/monitor/toolbar.py,sha256=T_Snin6N3NpzTkSVMVTfKsbXyyv5Tj6hJEbXvTefEqY,10339
+qulab/monitor/dataset.py,sha256=q9ex0MnC0k-_h1dMFDXZWLERCjM2xPqEc-Obt4AsVZQ,6232
+qulab/monitor/event_queue.py,sha256=Pp9MQ5NtOHBxohHNjv9YfXI1H4T-eDshv3AhjOKp7tE,4501
+qulab/monitor/mainwindow.py,sha256=sGrSDUUZv0ilaw-T-7h4fa-TtmDluMsLNRnUADKgEQE,10043
+qulab/monitor/monitor.py,sha256=3vJeMRKtlDwQHsOz7cZlbNNAQbaCoKRFCgLxri5dtpo,9814
+qulab/monitor/ploter.py,sha256=cPyc1TyHHoKsaCbzIDHMUVwjKqPZLjjvBQb-fm8VKaw,4882
+qulab/monitor/qt_compat.py,sha256=vbblAzlw4pKo-F9yPZt4DOc-KdsSBucud1F8jv00G18,1730
+qulab/monitor/toolbar.py,sha256=A4UtLCnBWyk_JZ16u66dmcoTwY6-Cg4h6QQEEp3Ub-0,10363
 qulab/scan/__init__.py,sha256=Z88CzGsvr1VdKbF6aYgQv3j-fsEkKmqvpvX4LlzOM98,87
 qulab/scan/curd.py,sha256=tiJ0oo2DqirK2fpAAAA-6OFAjAuKG5W21nLqfLvTLyQ,6895
 qulab/scan/models.py,sha256=JFofv-RH0gpS3--M6izXiQg7iGkS9a_em2DwhS5kTTk,17626
@@ -89,16 +89,16 @@ qulab/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/tools/connection_helper.py,sha256=o1t6UpJQPyj4mWY66axgQkgsqUzdkhEGBJo44x9U1iE,946
 qulab/visualization/__init__.py,sha256=26cuHt3QIJXUb3VaMxlJx3IQTOUVJFKlYBZr7WMP53M,6129
 qulab/visualization/__main__.py,sha256=9zKK3yZFy0leU40ou6BpRC1Fsetfc1gjjFzIZYIwP6Y,1639
-qulab/visualization/_autoplot.py,sha256=31B7pn1pK19abpQDGYBU9a_27cDL87LBpx9vKqlcYAo,14165
-qulab/visualization/plot_circ.py,sha256=qZS3auNG4qIyUvC-ijTce17xJwGBvpRvPUqPEx64KUY,8759
-qulab/visualization/plot_layout.py,sha256=n9yEmCOl7RJw2l0hXXRVsnLfDOMlK7A52kQZG_Y_NgM,17630
+qulab/visualization/_autoplot.py,sha256=2ECb2USU3_MSwo2d8qzMMO4DK9OU1bA6RYr7FCss1D0,14369
+qulab/visualization/plot_circ.py,sha256=Lxi-Nnik9MBtsNur0iyp9DTdy_IMALRsHBg2hZbPkGc,8769
+qulab/visualization/plot_layout.py,sha256=Q8yOGYQ-oOle1W7cN4am9ABI8T-Xtk3W6BEX5bFSeWg,20464
 qulab/visualization/plot_seq.py,sha256=UWTS6p9nfX_7B8ehcYo6UnSTUCjkBsNU9jiOeW2calY,6751
 qulab/visualization/qdat.py,sha256=ZeevBYWkzbww4xZnsjHhw7wRorJCBzbG0iEu-XQB4EA,5735
 qulab/visualization/rot3d.py,sha256=CuLfG1jw1032HNNZxzC0OWtNzKsbj2e2WRYhMWDgvMQ,1321
 qulab/visualization/widgets.py,sha256=6KkiTyQ8J-ei70LbPQZAK35wjktY47w2IveOa682ftA,3180
-qulab-2.11.15.dist-info/licenses/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
-qulab-2.11.15.dist-info/METADATA,sha256=wwaZbMBIXvh3I9Gc2xzjmwqK10kmhsFaTHVTs11Ypl0,3945
-qulab-2.11.15.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-qulab-2.11.15.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
-qulab-2.11.15.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-qulab-2.11.15.dist-info/RECORD,,
+qulab-2.12.0.dist-info/licenses/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
+qulab-2.12.0.dist-info/METADATA,sha256=ciOrjSwiDMrPsQizRcfSzDphr_TCmgrDFjx3Njx6qto,3944
+qulab-2.12.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+qulab-2.12.0.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
+qulab-2.12.0.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+qulab-2.12.0.dist-info/RECORD,,