QuLab 2.3.5__cp310-cp310-win_amd64.whl → 2.4.0__cp310-cp310-win_amd64.whl

qulab/executor/transform.py

@@ -0,0 +1,90 @@
+import loguru
+
+from .storage import Result
+
+
+def _query_config(name: str, default=None):
+    import pickle
+
+    try:
+        with open('parameters.pkl', 'rb') as f:
+            parameters = pickle.load(f)
+    except:
+        parameters = {}
+
+    return parameters.get(name, default)
+
+
+def _update_config(updates):
+    import pickle
+
+    try:
+        with open('parameters.pkl', 'rb') as f:
+            parameters = pickle.load(f)
+    except:
+        parameters = {}
+
+    for k, v in updates.items():
+        parameters[k] = v
+
+    with open('parameters.pkl', 'wb') as f:
+        pickle.dump(parameters, f)
+
+
+def update_parameters(result: Result):
+    update_config(result.params)
+
+
+def result_to_params(result: Result | None) -> tuple | None:
+    if result is None:
+        return None
+
+    state = 'Bad data'
+    match (result.in_spec, result.bad_data):
+        case (True, False):
+            state = 'In spec'
+        case (False, True):
+            state = 'Bad data'
+        case (False, False):
+            state = 'Out of spec'
+
+    return state, result.params, result.info
+
+
+def params_to_result(params: tuple) -> Result:
+    state, cali, info = params
+    result = Result()
+    if state in ['In spec', 'OK']:
+        result.in_spec = True
+        result.bad_data = False
+    elif state == ['Bad data', 'Bad']:
+        result.bad_data = True
+        result.in_spec = False
+    else:
+        result.bad_data = False
+        result.in_spec = False
+    result.params = cali
+    result.info = info
+    return result
+
+
+query_config = _query_config
+update_config = _update_config
+
+
+def set_config_api(query_method, update_method):
+    """
+    Set the query and update methods for the config.
+
+    Args:
+        query_method: The query method.
+            the method should take a key and return the value.
+        update_method: The update method.
+            the method should take a dict of updates.
+    """
+    global query_config, update_config
+
+    query_config = query_method
+    update_config = update_method
+
+    return query_config, update_config

qulab/executor/utils.py

@@ -0,0 +1,107 @@
+from pathlib import Path
+
+from .load import load_workflow
+
+
+class Node:
+
+    def __init__(self, name: str):
+        self.name = name
+        self.dependents = []
+
+
+class Tree:
+
+    def __init__(self):
+        self.nodes = {}
+        self.heads = []
+
+    def add_node(self, node: str):
+        self.nodes[node] = Node(node)
+
+
+def dependent_tree(node: str, code_path: str | Path) -> dict[str, list[str]]:
+    '''
+    Returns a dict of nodes and their dependents.
+    '''
+    tree = {}
+    for n in load_workflow(node, code_path).depends()[0]:
+        tree[n] = dependent_tree(n, code_path)
+    return tree
+
+
+def workflow_template(deps: list[str]) -> str:
+    return f"""
+from loguru import logger
+
+import numpy as np
+
+
+# 多长时间应该检查一次校准实验，单位是秒。
+__timeout__ = 200
+
+def depends():
+    return [{deps!r}]
+
+
+def calibrate():
+    logger.info(f"run {{__name__}}")
+
+    # calibrate 是一个完整的校准实验，如power Rabi，Ramsey等。
+    # 你需要足够的扫描点，以使得后续的 analyze 可以拟合出合适的参数。
+
+    # 这里只是一个示例，实际上你需要在这里写上你的校准代码。
+    x = np.linspace(0, 2*np.pi, 101)
+    y = []
+    for i in x:
+        y.append(np.sin(i))
+
+    return x, y
+
+
+def analyze(*args, history):
+    import random
+
+    # 完整校准后的状态有两种：OK 和 Bad，分别对应校准成功和校准失败。
+    # 校准失败是指出现坏数据，无法简单通过重新运行本次校准解决，需要
+    # 检查前置步骤。
+    state = random.choice(['OK', 'Bad'])
+
+    # 参数是一个字典，包含了本次校准得到的参数，后续会更新到config表中。
+    parameters = {{'gate.R.Q1.params.amp':1}}
+
+    # 其他信息可以是任何可序列化的内容，你可以将你想要记录的信息放在这里。
+    # 下次校准分析时，这些信息也会在 history 参数中一起传入，帮助你在下
+    # 次分析时对比参考。
+    other_infomation = {{}}
+
+    return state, parameters, other_infomation
+
+
+def check():
+    logger.info(f"check {{__name__}}")
+
+    # check 是一个快速检查实验，用于检查校准是否过时。
+    # 你只需要少数扫描点，让后续的 check_analyze 知道参数是否漂移，数据
+    # 坏没坏就够了，不要求拟合。
+
+    # 这里只是一个示例，实际上你需要在这里写上你的检查代码。
+    x = np.linspace(0, 2*np.pi, 5)
+    y = []
+    for i in x:
+        y.append(np.sin(i))
+
+    return x, y
+
+
+def check_analyze(*args, history):
+    import random
+
+    # 状态有三种：Outdated, OK, Bad，分别对应过时、正常、坏数据。
+    # Outdated 是指数据过时，即参数漂了，需要重新校准。
+    # OK 是指数据正常，参数也没漂，不用重新校准。
+    # Bad 是指数据坏了，无法校准，需要检查前置步骤。
+    state = random.choice(['Outdated', 'OK', 'Bad'])
+
+    return state, {{}}, {{}}
+"""

qulab/scan/curd.py

@@ -7,7 +7,7 @@ from typing import Sequence, Type, Union
 from sqlalchemy.orm import Query, Session, aliased
 from sqlalchemy.orm.exc import NoResultFound
 from sqlalchemy.orm.session import Session
-from waveforms.dicttree import foldDict
+from ..dicttree import foldDict
 
 from .models import (Cell, Comment, Config, InputText, Notebook, Record,
                      Report, Sample, Tag, utcnow)

qulab/scan/expression.py

@@ -420,6 +420,10 @@ class Expression():
         return False
 
     def value(self, env=_default_env):
+        if isinstance(env, dict):
+            e = Env()
+            e.variables = env
+            env = e
         if self.changed(env):
             self.cache = self.eval(env)
         return self.cache

qulab/scan/models.py

@@ -8,7 +8,6 @@ from sqlalchemy import (Column, DateTime, Float, ForeignKey, Integer,
 from sqlalchemy.orm import (backref, declarative_base, relationship,
                             sessionmaker)
 from sqlalchemy.orm.session import Session
-from waveforms.security import InvalidKey, encryptPassword, verifyPassword
 
 
 def utcnow():
@@ -107,15 +106,15 @@ class User(Base):
     attachments = relationship('Attachment', back_populates='user')
     comments = relationship('Comment', back_populates='user')
 
-    def setPassword(self, password):
-        self.hashed_password = encryptPassword(password)
+    # def setPassword(self, password):
+    #     self.hashed_password = encryptPassword(password)
 
-    def verify(self, password):
-        try:
-            verifyPassword(password, self.hashed_password)
-            return True
-        except InvalidKey:
-            return False
+    # def verify(self, password):
+    #     try:
+    #         verifyPassword(password, self.hashed_password)
+    #         return True
+    #     except InvalidKey:
+    #         return False
 
     def __repr__(self):
         return f"User(name='{self.name}')"
@@ -526,13 +525,13 @@ def create_tables(engine, tables_only=False):
     root_role = Role(name='root')
     admin_role = Role(name='admin')
     root_user = User(name='root')
-    root_user.setPassword('123')
+    # root_user.setPassword('123')
     root_user.roles.append(root_role)
     root_user.roles.append(admin_role)
 
     guest_role = Role(name='guest')
     guest_user = User(name='guest')
-    guest_user.setPassword('')
+    # guest_user.setPassword('')
     guest_user.roles.append(guest_role)
 
     t1 = SampleAccountType(name='factory')

qulab/scan/server.py

@@ -73,13 +73,13 @@ def clear_cache():
         return
 
     logger.debug(f"clear_cache record_cache: {len(record_cache)}")
-    for (k, (t, r),
+    for ((k, (t, r)),
          i) in zip(sorted(record_cache.items(), key=lambda x: x[1][0]),
                    range(len(record_cache) - CACHE_SIZE)):
         del record_cache[k]
 
     logger.debug(f"clear_cache buffer_list_cache: {len(buffer_list_cache)}")
-    for (k, (t, r),
+    for ((k, (t, r)),
          i) in zip(sorted(buffer_list_cache.items(), key=lambda x: x[1][0]),
                    range(len(buffer_list_cache) - CACHE_SIZE)):
         del buffer_list_cache[k]
@@ -276,7 +276,10 @@ async def handle(session: Session, request: Request, datapath: Path):
         case 'notebook_extend':
             notebook = session.get(Notebook, msg['notebook_id'])
             inputCells = msg.get('input_cells', [""])
-            aready_saved = len(notebook.cells)
+            try:
+                aready_saved = len(notebook.cells)
+            except:
+                aready_saved = 0
             if len(inputCells) > aready_saved:
                 for cell in inputCells[aready_saved:]:
                     cell = create_cell(session, notebook, cell)

qulab/sys/device/basedevice.py

@@ -12,6 +12,14 @@ Decorator = Callable[[Callable], Callable]
 _buildin_set = set
 
 
+class Source():
+    pass
+
+
+class Sink():
+    pass
+
+
 def action(key: str,
            method: Literal['get', 'set', 'post', 'delete'] = 'get',
            **kwds) -> Decorator:

qulab/sys/device/utils.py

@@ -2,6 +2,20 @@ import struct
 
 import numpy as np
 
+types = {
+    "b"      : (  int, 'b'), "B"      : (  int, 'B'),
+    "h"      : (  int, 'h'), "H"      : (  int, 'H'),
+    "i"      : (  int, 'i'), "I"      : (  int, 'I'),
+    "q"      : (  int, 'q'), "Q"      : (  int, 'Q'),
+    "f"      : (float, 'f'), "d"      : (float, 'd'),
+    "int8"   : (  int, 'b'), "uint8"  : (  int, 'B'),
+    "int16"  : (  int, 'h'), "uint16" : (  int, 'H'),
+    "int32"  : (  int, 'i'), "uint32" : (  int, 'I'),
+    "int64"  : (  int, 'q'), "uint64" : (  int, 'Q'),
+    "float"  : (float, 'f'), "double" : (float, 'd'),
+    "float32": (float, 'f'), "float64": (float, 'd')
+} # yapf: disable
+
 
 def IEEE_488_2_BinBlock(datalist, dtype="int16", is_big_endian=True):
     """
@@ -16,19 +30,6 @@ def IEEE_488_2_BinBlock(datalist, dtype="int16", is_big_endian=True):
         binblock, header
         二进制块, 以及其 'header'
     """
-    types = {"b"      : (  int, 'b'), "B"      : (  int, 'B'),
-             "h"      : (  int, 'h'), "H"      : (  int, 'H'),
-             "i"      : (  int, 'i'), "I"      : (  int, 'I'),
-             "q"      : (  int, 'q'), "Q"      : (  int, 'Q'),
-             "f"      : (float, 'f'), "d"      : (float, 'd'),
-             "int8"   : (  int, 'b'), "uint8"  : (  int, 'B'),
-             "int16"  : (  int, 'h'), "uint16" : (  int, 'H'),
-             "int32"  : (  int, 'i'), "uint32" : (  int, 'I'),
-             "int64"  : (  int, 'q'), "uint64" : (  int, 'Q'),
-             "float"  : (float, 'f'), "double" : (float, 'd'),
-             "float32": (float, 'f'), "float64": (float, 'd')
-    } # yapf: disable
-
     if isinstance(datalist, bytes):
         datablock = datalist
     else:
@@ -44,3 +45,35 @@ def IEEE_488_2_BinBlock(datalist, dtype="int16", is_big_endian=True):
     header = '#%d%s' % (len(size), size)
 
     return header.encode() + datablock
+
+
+def decode_IEEE_488_2_BinBlock(data, dtype="int16", is_big_endian=True):
+    """
+    解析 IEEE 488.2 标准二进制块
+
+    Args:
+        data : 二进制块
+        dtype : 数据类型
+        endian : 字节序
+
+    Returns:
+        datalist
+    """
+    if isinstance(data, bytes):
+        header = data[:2]
+        size = int(data[2:2 + int(header[1:2])])
+        assert size == len(data) - 2 - int(header[1:2]), "data size error"
+        datablock = data[2 + int(header[1:2]):size + 2 + int(header[1:2])]
+    else:
+        raise ValueError("data must be bytes")
+
+    if is_big_endian:
+        endianc = '>'
+    else:
+        endianc = '<'
+    datalist = list(
+        struct.unpack(
+            '%s%d%s' % (endianc, size // struct.calcsize(types[dtype][1]),
+                        types[dtype][1]), datablock))
+
+    return datalist

qulab/sys/rpc/router.py

@@ -0,0 +1,35 @@
+import asyncio
+import random
+
+import zmq
+import zmq.asyncio
+
+
+async def handle_client(socket, identity, message):
+    print(f"Received request from {identity}: {message.decode()}")
+    # 随机延时 0 到 3 秒
+    await asyncio.sleep(random.uniform(0, 3))
+    task_id = random.randint(1000, 9999)  # 随机生成一个任务 ID
+    await socket.send_multipart([identity, f"Task ID: {task_id}".encode()])
+    print(f"Sent Task ID {task_id} to {identity}")
+
+
+async def server():
+    context = zmq.asyncio.Context()
+    socket = context.socket(zmq.ROUTER)
+    socket.bind("tcp://*:5555")
+
+    while True:
+        try:
+            identity, message = await socket.recv_multipart()
+            asyncio.create_task(handle_client(socket, identity, message))
+        except Exception as e:
+            print(f"An error occurred: {e}")
+            break
+
+    socket.close()
+    context.term()
+
+
+if __name__ == "__main__":
+    asyncio.run(server())

qulab/version.py

@@ -1 +1 @@
-__version__ = "2.3.5"
+__version__ = "2.4.0"

qulab/visualization/_autoplot.py

@@ -239,8 +239,8 @@ def plot_img(x,
     kwds.setdefault('aspect', 'auto')
     kwds.setdefault('interpolation', 'nearest')
 
-    vmin = kwds.get('vmin', np.nanmin(z))
-    vmax = kwds.get('vmax', np.nanmax(z))
+    vmin = kwds.pop('vmin', np.nanmin(z))
+    vmax = kwds.pop('vmax', np.nanmax(z))
     if zscale == 'log':
         kwds.setdefault('norm', LogNorm(vmax=vmax, vmin=vmin))
     elif zscale == 'symlog':
@@ -262,7 +262,8 @@ def plot_img(x,
         kwds.pop('origin', None)
         kwds.pop('aspect', None)
         kwds.pop('interpolation', None)
-        pc = ax.pcolormesh(x, y, z, **kwds)
+        shading = kwds.pop('shading', 'nearest')
+        pc = ax.pcolormesh(x, y, z, shading=shading, **kwds)
         xlabel = f"{xlabel} [{x_unit}]" if x_unit else xlabel
         ylabel = f"{ylabel} [{y_unit}]" if y_unit else ylabel
         ax.set_xlabel(xlabel)