QuLab 2.0.0__py3-none-any.whl → 2.10.12__py3-none-any.whl

qulab/__init__.py

@@ -1 +1,33 @@
-from .version import __version__
+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)
+from qlispc import (COMMAND, FREE, NOTSET, PUSH, READ, SYNC, TRIG, WRITE,
+                    compile, get_arch, libraries, mapping_qubits,
+                    register_arch)
+from qlispc.kernel_utils import qcompile
+from wath import (Interval, Primes, Transmon, Z2probs, complex_amp_to_real,
+                  effective_temperature, exception, find_axis_of_symmetry,
+                  find_center_of_symmetry, find_cross_point, fit_circle,
+                  fit_cosine, fit_k, fit_max, fit_peaks, fit_pole, getFTMatrix,
+                  graph, inv_poly, lin_fit, point_in_ellipse, point_in_polygon,
+                  point_on_ellipse, point_on_segment, poly_fit, probs2Z,
+                  relative_delay_to_absolute, thermal_excitation, viterbi_hmm)
+from waveforms import (D, chirp, const, cos, cosh, coshPulse, cosPulse, cut,
+                       drag, drag_sin, drag_sinx, exp, function, gaussian,
+                       general_cosine, hanning, interp, mixing, one, poly,
+                       registerBaseFunc, registerDerivative, samplingPoints,
+                       sign, sin, sinc, sinh, square, step, t, wave_eval, zero)
+
+from .executor.analyze import manual_analysis
+from .executor.registry import Registry
+from .executor.storage import find_report
+from .executor.storage import get_report_by_index as get_report
+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

qulab/__main__.py

@@ -0,0 +1,4 @@
+from .cli.commands import cli
+
+if __name__ == '__main__':
+    cli()

qulab/cli/commands.py

@@ -0,0 +1,31 @@
+import click
+
+from ..executor.cli import boot, create, get, maintain, reproduce, run, set
+from ..monitor.__main__ import main as monitor
+from ..scan.server import server
+from ..sys.net.cli import dht
+from ..visualization.__main__ import plot
+
+
+@click.group()
+def cli():
+    pass
+
+
+@cli.command()
+def hello():
+    """Print hello world."""
+    click.echo('hello, world')
+
+
+cli.add_command(monitor)
+cli.add_command(plot)
+cli.add_command(dht)
+cli.add_command(server)
+cli.add_command(maintain)
+cli.add_command(run)
+cli.add_command(reproduce)
+cli.add_command(create)
+cli.add_command(set)
+cli.add_command(get)
+cli.add_command(boot)

qulab/cli/config.py

@@ -0,0 +1,170 @@
+import configparser
+import functools
+import os
+import sys
+from pathlib import Path
+
+import click
+from loguru import logger
+
+CONFIG_PATH = os.path.expanduser("~/.qulab.ini")
+ENV_PREFIX = "QULAB_"
+
+
+def _get_config_value(option_name,
+                      type_cast=str,
+                      command_name=None,
+                      default=None):
+    """支持命令专属配置的优先级获取"""
+    # 构造环境变量名
+    if command_name:
+        env_var = f"{ENV_PREFIX}{command_name.upper()}_{option_name.upper()}"
+        config_section = command_name
+    else:
+        env_var = f"{ENV_PREFIX}{option_name.upper()}"
+        config_section = "common"
+
+    # 1. 检查环境变量
+    if env_value := os.getenv(env_var):
+        if type_cast is bool:
+            return env_value.lower() in ("true", "1", "yes")
+        if "path" in option_name or issubclass(type_cast, Path):
+            return Path(os.path.expanduser(env_value))
+        return type_cast(env_value)
+
+    # 2. 检查配置文件
+    config = configparser.ConfigParser()
+    # 先加载默认配置防止段不存在
+    config.read_dict({config_section: {}})
+    if Path(CONFIG_PATH).exists():
+        config.read(CONFIG_PATH)
+
+    # 从对应配置段读取
+    if config.has_section(config_section):
+        if config_value := config.get(config_section,
+                                      option_name,
+                                      fallback=None):
+            if type_cast is bool:
+                return config_value.lower() in ("true", "1", "yes")
+            if "path" in option_name or issubclass(type_cast, Path):
+                return Path(os.path.expanduser(config_value))
+            return type_cast(config_value)
+
+    return default  # 交给 Click 处理默认值
+
+
+def get_config_value(option_name,
+                     type_cast=str,
+                     command_name=None,
+                     default=None):
+    """
+    获取配置值，支持命令专属配置的优先级获取
+
+    优先级：
+    1. 命令行参数
+    2. 配置文件专属配置
+    3. 配置文件公共配置
+    4. 环境变量专属配置
+    5. 环境变量公共配置
+    6. 默认值
+    7. Click 处理默认值
+    8. None
+
+    Parameters
+    ----------
+    option_name : str
+        配置项名称
+    type_cast : type
+        转换类型
+    command_name : str
+        命令名称
+        如果为 None，则不使用命令专属配置
+    default : any
+        默认值
+        如果为 None，则不使用默认值
+    
+    Returns
+    -------
+    any
+        配置值
+        如果没有找到配置值，则返回 None
+    """
+    value = _get_config_value(option_name,
+                              type_cast,
+                              command_name,
+                              default=default)
+    if value is None and command_name is not None:
+        return _get_config_value(option_name, type_cast, default=default)
+    return value
+
+
+def log_options(func=None, command_name=None):
+    """通用配置装饰器（所有命令共用)
+    
+    添加 --debug, --log, --debug-log, --quiet 选项
+    1. --debug: 是否开启调试模式
+    2. --log: 日志文件路径
+    3. --debug-log: 调试日志文件路径
+    4. --quiet: 是否静默输出
+    """
+
+    if isinstance(func, str):
+        return functools.partial(log_options, command_name=func)
+    if func is None:
+        return functools.partial(log_options, command_name=command_name)
+
+    @click.option("--debug",
+                  is_flag=True,
+                  default=get_config_value("debug",
+                                           bool,
+                                           command_name=command_name),
+                  help=f"Enable debug mode")
+    @click.option("--log",
+                  type=click.Path(),
+                  default=lambda: get_config_value(
+                      "log", Path, command_name=command_name),
+                  help=f"Log file path")
+    @click.option("--debug-log",
+                  type=click.Path(),
+                  default=lambda: get_config_value(
+                      "debug_log", Path, command_name=command_name),
+                  help=f"Debug log file path")
+    @click.option("--quiet",
+                  is_flag=True,
+                  default=get_config_value("quiet",
+                                           bool,
+                                           command_name=command_name),
+                  help=f"Disable log output")
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        debug = bool(kwargs.pop("debug"))
+        log = kwargs.pop("log")
+        debug_log = kwargs.pop("debug_log")
+        quiet = bool(kwargs.pop("quiet"))
+
+        if debug:
+            log_level = "DEBUG"
+        else:
+            log_level = "INFO"
+
+        handlers = []
+        if log is not None:
+            handlers.append(
+                dict(sink=log,
+                     level="INFO",
+                     rotation="monday at 7:00",
+                     compression="zip"))
+        if debug_log is not None:
+            handlers.append(
+                dict(sink=debug_log,
+                     level="DEBUG",
+                     rotation="monday at 7:00",
+                     compression="zip"))
+        if not quiet or debug:
+            handlers.append(dict(sink=sys.stderr, level=log_level))
+
+        logger.configure(handlers=handlers)
+
+        return func(*args, **kwargs)
+
+    return wrapper

qulab/cli/decorators.py

@@ -0,0 +1,28 @@
+import asyncio
+import functools
+import inspect
+
+
+def async_command(func=None):
+    """
+    Decorator to mark a function as an asynchronous command.
+    """
+    if func is None:
+        return async_command
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        return run(func, *args, **kwargs)
+
+    return wrapper
+
+
+def run(main, *args, **kwds):
+    if inspect.iscoroutinefunction(main):
+        try:
+            import uvloop
+            uvloop.run(main(*args, **kwds))
+        except (ImportError, ModuleNotFoundError):
+            asyncio.run(main(*args, **kwds))
+    else:
+        main(*args, **kwds)

qulab/executor/__init__.py

@@ -0,0 +1,5 @@
+from loguru import logger
+
+from .schedule import maintain, run
+
+# logger.configure(handlers=[])

qulab/executor/analyze.py

@@ -0,0 +1,188 @@
+import pickle
+import threading
+import time
+
+import pyperclip
+import zmq
+
+from .storage import Report
+
+# 需要复制到 Notebook 的代码模板
+clip_template = """
+from qulab.executor.analyze import get_report as get_report_{server_port}
+
+report, history = get_report_{server_port}("tcp://{server_address}:{server_port}")
+# 在这里插入数据处理逻辑
+
+{analysis_code}
+"""
+
+analysis_code = """
+# report.state = 'OK'
+# report.parameters = {}
+# report.oracle = {}
+# report.other_infomation = {}
+
+report.parameters
+
+"""
+
+
+# ZeroMQ 服务线程，用于响应 Notebook 的请求
+class ServerThread(threading.Thread):
+
+    def __init__(self, data, timeout):
+        super().__init__()
+        self.data = data
+        self.result = None
+        self.port = 0
+        self.timeout = timeout
+        self.running = True
+        self.finished = threading.Event()
+        self.context = zmq.Context()
+
+    def find_free_port(self):
+        with zmq.Socket(self.context, zmq.REQ) as s:
+            s.bind_to_random_port("tcp://*")
+            self.port = int(
+                s.getsockopt(zmq.LAST_ENDPOINT).decode().split(":")[-1])
+            s.unbind(s.getsockopt(zmq.LAST_ENDPOINT))
+        return self.port
+
+    def run(self):
+        self.port = self.find_free_port()
+        socket = self.context.socket(zmq.REP)
+        socket.bind(f"tcp://*:{self.port}")
+        # 设置 recv 超时 1 秒
+        socket.RCVTIMEO = 1000
+        start_time = time.time()
+        try:
+            while self.running and (time.time() - start_time < self.timeout):
+                try:
+                    msg = socket.recv()
+                except zmq.Again:
+                    continue  # 超时后继续等待
+
+                # Notebook 端请求数据
+                if msg == b"GET":
+                    socket.send(pickle.dumps(self.data))
+                else:
+                    # Notebook 端提交了处理结果
+                    try:
+                        self.result = pickle.loads(msg)
+                    except Exception as e:
+                        # 如果解析失败，也返回默认 ACK
+                        self.result = None
+                    socket.send(b"ACK")
+                    self.running = False
+                    break
+        finally:
+            socket.close()
+            self.context.term()
+            self.finished.set()
+
+    def stop(self):
+        self.running = False
+        self.finished.set()
+
+    def wait_for_result(self):
+        self.finished.wait()
+        return self.result
+
+
+# 进入分析流程，启动服务并打印等待提示
+def get_result_or_wait_until_timeout(report: Report, history: Report | None,
+                                     timeout: float) -> Report:
+    server = ServerThread((report, history), timeout)
+    server.start()
+
+    parameters = report.parameters
+    oracle = report.oracle
+    other_infomation = report.other_infomation
+    state = report.state
+
+    # 格式化代码模板
+    code = clip_template.format(server_address="127.0.0.1",
+                                server_port=server.port,
+                                analysis_code=analysis_code)
+
+    # 将代码复制到剪切板
+    pyperclip.copy(code)
+
+    # 同时打印到终端，防止误操作导致剪切板内容丢失
+    print("请在 Jupyter Notebook 中运行下面这段代码：")
+    print("-" * 60)
+    print(code)
+    print("-" * 60)
+    print("等待 Notebook 提交处理结果，或等待超时（{} 秒）...".format(timeout))
+
+    start_time = time.time()
+    # 采用循环等待提交结果，间隔 0.5 秒检测一次
+    while server.finished.wait(timeout=0.5) is False:
+        elapsed = time.time() - start_time
+        if elapsed >= timeout:
+            # 超时后结束等待
+            server.stop()
+            break
+
+    result = server.wait_for_result()
+    if result is None:
+        return (state, parameters, oracle, other_infomation, code)
+    else:
+        return result
+
+
+def manual_analysis(report: Report, history=None, timeout=3600):
+    try:
+        (state, parameters, oracle, other_infomation,
+         code) = get_result_or_wait_until_timeout(report, history, timeout)
+        report.parameters = parameters
+        report.oracle = oracle
+        report.state = state
+        report.other_infomation = other_infomation
+    except Exception as e:
+        pass
+    return report
+
+
+def get_report(address: str) -> Report:
+    import IPython
+
+    ipy = IPython.get_ipython()
+    if ipy is None:
+        raise RuntimeError("请在 Jupyter Notebook 中运行此函数。")
+    ipy.set_next_input(("from qulab.executor.analyze import submit_report\n"
+                        "# 处理完成后，提交结果\n"
+                        f"# submit_report(report, \"{address}\")"),
+                       replace=False)
+    context = zmq.Context()
+    sock = context.socket(zmq.REQ)
+    sock.connect(address)
+    # 请求数据
+    sock.send(b"GET")
+    report, history = pickle.loads(sock.recv())
+    return report, history
+
+
+def submit_report(report: Report, address: str):
+    import IPython
+
+    ipy = IPython.get_ipython()
+    if ipy is None:
+        raise RuntimeError("请在 Jupyter Notebook 中运行此函数。")
+
+    code = ipy.user_ns['In'][-2]
+
+    parameters = report.parameters
+    oracle = report.oracle
+    other_infomation = report.other_infomation
+    state = report.state
+
+    context = zmq.Context()
+    sock = context.socket(zmq.REQ)
+    sock.connect(address)
+    # 提交处理后的结果
+    sock.send(pickle.dumps(
+        (state, parameters, oracle, other_infomation, code)))
+    ack = sock.recv()
+    print("结果已提交。")