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

qulab/scan/utils.py

@@ -1,37 +1,233 @@
+import ast
+import asyncio
 import inspect
-from concurrent.futures import Future
-
-
-def call_func_with_kwds(func, args, kwds, log=None):
-    funcname = getattr(func, '__name__', repr(func))
-    sig = inspect.signature(func)
-    for p in sig.parameters.values():
-        if p.kind == p.VAR_KEYWORD:
-            return func(*args, **kwds)
-    kw = {
-        k: v
-        for k, v in kwds.items()
-        if k in list(sig.parameters.keys())[len(args):]
-    }
+import platform
+import re
+import subprocess
+import sys
+import uuid
+import warnings
+from typing import Any, Callable
+
+import dill
+from qlispreg.expression import Env, Expression
+
+
+class Unpicklable:
+
+    def __init__(self, obj):
+        self.type = str(type(obj))
+        self.id = id(obj)
+
+    def __repr__(self):
+        return f'<Unpicklable: {self.type} at 0x{id(self):x}>'
+
+
+class TooLarge:
+
+    def __init__(self, obj):
+        self.type = str(type(obj))
+        self.id = id(obj)
+
+    def __repr__(self):
+        return f'<TooLarge: {self.type} at 0x{id(self):x}>'
+
+
+def dump_dict(d, keys=[]):
+    ret = {}
+
+    for key, value in d.items():
+        if key in keys:
+            ret[key] = value
+            continue
+        if isinstance(value, dict) and isinstance(key, str):
+            ret[key] = dump_dict(value,
+                                 keys=[
+                                     k[len(key) + 1:] for k in keys
+                                     if k.startswith(f'{key}.')
+                                 ])
+        else:
+            try:
+                ret[key] = dill.dumps(value)
+            except:
+                ret[key] = Unpicklable(value)
+
+    return dill.dumps(ret)
+
+
+def load_dict(buff):
+    if isinstance(buff, dict):
+        return {key: load_dict(value) for key, value in buff.items()}
+
+    if not isinstance(buff, bytes):
+        return buff
+
     try:
-        args = [
-            arg.result() if isinstance(arg, Future) else arg for arg in args
-        ]
-        kw = {
-            k: v.result() if isinstance(v, Future) else v
-            for k, v in kw.items()
-        }
-        return func(*args, **kw)
+        ret = dill.loads(buff)
     except:
-        if log:
-            log.exception(f'Call {funcname} with {args} and {kw}')
-        raise
-    finally:
-        if log:
-            log.debug(f'Call {funcname} with {args} and {kw}')
-
-
-def try_to_call(x, args, kwds, log=None):
-    if callable(x):
-        return call_func_with_kwds(x, args, kwds, log)
-    return x
+        return buff
+
+    if isinstance(ret, dict):
+        return load_dict(ret)
+    else:
+        return ret
+
+
+def dump_globals(ns=None, *, size_limit=10 * 1024 * 1024, warn=False):
+    import __main__
+
+    if ns is None:
+        ns = __main__.__dict__
+
+    namespace = {}
+
+    for name, value in ns.items():
+        try:
+            buf = dill.dumps(value)
+        except:
+            namespace[name] = Unpicklable(value)
+            if warn:
+                warnings.warn(f'Unpicklable: {name} {type(value)}')
+        if len(buf) > size_limit:
+            namespace[name] = TooLarge(value)
+            if warn:
+                warnings.warn(f'TooLarge: {name} {type(value)}')
+        else:
+            namespace[name] = buf
+
+    return namespace
+
+
+def is_valid_identifier(s: str) -> bool:
+    """
+    Check if a string is a valid identifier.
+    """
+    try:
+        ast.parse(f"f({s}=0)")
+        return True
+    except SyntaxError:
+        return False
+
+
+async def async_next(aiter):
+    try:
+        if hasattr(aiter, '__anext__'):
+            return await aiter.__anext__()
+        else:
+            return next(aiter)
+    except StopIteration:
+        raise StopAsyncIteration from None
+
+
+async def async_zip(*aiters):
+    aiters = [
+        ait.__aiter__() if hasattr(ait, '__aiter__') else iter(ait)
+        for ait in aiters
+    ]
+    try:
+        while True:
+            # 使用 asyncio.gather 等待所有异步生成器返回下一个元素
+            result = await asyncio.gather(*(async_next(ait) for ait in aiters))
+            yield tuple(result)
+    except StopAsyncIteration:
+        # 当任一异步生成器耗尽时停止迭代
+        return
+
+
+async def call_function(func: Callable | Expression, variables: dict[str,
+                                                                     Any]):
+    if isinstance(func, Expression):
+        env = Env()
+        for name in func.symbols():
+            if name in variables:
+                if inspect.isawaitable(variables[name]):
+                    variables[name] = await variables[name]
+                env.variables[name] = variables[name]
+            else:
+                raise ValueError(f'{name} is not provided.')
+        return func.eval(env)
+
+    try:
+        sig = inspect.signature(func)
+    except:
+        return func()
+    args = []
+    for name, param in sig.parameters.items():
+        if param.kind == param.POSITIONAL_OR_KEYWORD:
+            if name in variables:
+                if inspect.isawaitable(variables[name]):
+                    variables[name] = await variables[name]
+                args.append(variables[name])
+            elif param.default is not param.empty:
+                args.append(param.default)
+            else:
+                raise ValueError(f'parameter {name} is not provided.')
+        elif param.kind == param.VAR_POSITIONAL:
+            raise ValueError('not support VAR_POSITIONAL')
+        elif param.kind == param.VAR_KEYWORD:
+            ret = func(**variables)
+            if inspect.isawaitable(ret):
+                ret = await ret
+            return ret
+    ret = func(*args)
+    if inspect.isawaitable(ret):
+        ret = await ret
+    return ret
+
+
+def yapf_reformat(cell_text):
+    try:
+        import isort
+        import yapf.yapflib.yapf_api
+
+        fname = f"f{uuid.uuid1().hex}"
+
+        def wrap(source):
+            lines = [f"async def {fname}():"]
+            for line in source.split('\n'):
+                lines.append("    " + line)
+            return '\n'.join(lines)
+
+        def unwrap(source):
+            lines = []
+            for line in source.split('\n'):
+                if line.startswith(f"async def {fname}():"):
+                    continue
+                lines.append(line[4:])
+            return '\n'.join(lines)
+
+        cell_text = re.sub('^%', '#%#', cell_text, flags=re.M)
+        try:
+            reformated_text = yapf.yapflib.yapf_api.FormatCode(
+                isort.code(cell_text))[0]
+        except:
+            reformated_text = unwrap(
+                yapf.yapflib.yapf_api.FormatCode(wrap(
+                    isort.code(cell_text)))[0])
+        return re.sub('^#%#', '%', reformated_text, flags=re.M)
+    except:
+        return cell_text
+
+
+def get_installed_packages():
+    result = subprocess.run([sys.executable, '-m', 'pip', 'freeze'],
+                            stdout=subprocess.PIPE,
+                            text=True)
+
+    lines = result.stdout.split('\n')
+    packages = []
+    for line in lines:
+        if line:
+            packages.append(line)
+    return packages
+
+
+def get_system_info():
+    info = {
+        'OS': platform.uname()._asdict(),
+        'Python': sys.version,
+        'PythonExecutable': sys.executable,
+        'PythonPath': sys.path,
+        'packages': get_installed_packages()
+    }
+    return info

qulab/sys/__init__.py

@@ -0,0 +1,2 @@
+from .device import (BaseDevice, VisaDevice, action, create_device, delete,
+                     exclude, get, post, set)

qulab/sys/device/basedevice.py

@@ -1,6 +1,8 @@
+import copy
 import itertools
 import logging
 import re
+import string
 from collections import defaultdict
 from functools import partial
 from typing import Any, Callable, Literal, NamedTuple
@@ -12,6 +14,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:
@@ -79,7 +89,8 @@ def _add_action(attrs: dict, key: str, method: str, func: Callable, doc: dict,
                 matrix[arg] = attrs[arg]
     for values in itertools.product(*[matrix[arg] for arg in arguments]):
         kwds = dict(zip(arguments, values))
-        mapping[key.format(**kwds)] = partial(func, **kwds)
+        # mapping[key.format(**kwds)] = partial(func, **kwds)
+        mapping[string.Template(key).substitute(kwds)] = partial(func, **kwds)
 
 
 def _build_docs(mapping: dict, attrs: dict) -> str:
@@ -117,7 +128,8 @@ class BaseDevice(metaclass=DeviceMeta):
     __log__ = None
 
     def __init__(self, address: str = None, **options):
-        self._status = {}
+        self._state = {}
+        self._status = "NOT CONNECTED"
         self.address = address
         self.options = options
 
@@ -134,28 +146,40 @@ class BaseDevice(metaclass=DeviceMeta):
                 f"{self.__class__.__module__}.{self.__class__.__name__}")
         return self.__log__
 
+    @property
+    def state(self):
+        return copy.deepcopy(self._state)
+    
+    def get_state(self, key: str, default=None) -> Any:
+        return self._state.get(key, default)
+
+    @property
+    def status(self):
+        return self._status
+
     def open(self) -> None:
-        pass
+        self._status = "CONNECTED"
 
     def close(self) -> None:
-        pass
+        self._status = "NOT CONNECTED"
+        self._state.clear()
 
     def reset(self) -> None:
-        self._status.clear()
+        self._state.clear()
 
     def get(self, key: str, default: Any = None) -> Any:
         self.log.info(f'Get {key!r}')
         if key in self.__get_actions__:
             result = self.__get_actions__[key](self)
-            self._status[key] = result
+            self._state[key] = result
             return result
         else:
-            return self._status.get(key, default)
+            return self._state.get(key, default)
 
     def set(self, key: str, value: Any = None) -> None:
         self.log.info(f'Set {key!r} = {value!r}')
         self.__set_actions__[key](self, value)
-        self._status[key] = value
+        self._state[key] = value
 
     def post(self, key: str, value: Any = None) -> Any:
         self.log.info(f'Post {key!r} = {value!r}')
@@ -164,7 +188,7 @@ class BaseDevice(metaclass=DeviceMeta):
     def delete(self, key: str) -> None:
         self.log.info(f'Delete {key!r}')
         self.__delete_actions__[key](self)
-        del self._status[key]
+        del self._state[key]
 
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}({self.address!r})'
@@ -172,6 +196,8 @@ class BaseDevice(metaclass=DeviceMeta):
 
 class VisaDevice(BaseDevice):
 
+    error_query = 'SYST:ERR?'
+
     def open(self) -> None:
         import pyvisa
         kwds = self.options.copy()
@@ -180,14 +206,26 @@ class VisaDevice(BaseDevice):
         else:
             rm = pyvisa.ResourceManager()
         self.resource = rm.open_resource(self.address, **kwds)
+        self.errors = []
+        super().open()
 
     def close(self) -> None:
+        super().close()
         self.resource.close()
 
     def reset(self) -> None:
         super().reset()
         self.resource.write('*RST')
 
+    def check_error(self):
+        if self.error_query:
+            while True:
+                error = self.resource.query(self.error_query)
+                error_code = int(error.split(',')[0])
+                if error_code == 0:
+                    break
+                self.errors.append(error)
+
     @get('idn')
     def get_idn(self) -> str:
         """Get instrument identification."""
@@ -201,13 +239,9 @@ class VisaDevice(BaseDevice):
     @get('errors')
     def get_errors(self) -> list[str]:
         """Get error queue."""
-        errors = []
-        while True:
-            error = self.resource.query('SYST:ERR?')
-            error_code = int(error.split(',')[0])
-            if error_code == 0:
-                break
-            errors.append(error)
+        self.check_error()
+        errors = self.errors
+        self.errors = []
         return errors
 
     @set('timeout')

qulab/sys/device/loader.py

@@ -79,7 +79,7 @@ def create_device(driver_name: str, *args, **kwds) -> BaseDevice:
             except:
                 pass
 
-        dev = create_device_from_module(f"waveforms.sys.drivers.{driver_name}",
+        dev = create_device_from_module(f"qulab.sys.drivers.{driver_name}",
                                         args, kwds)
         return dev
     except:

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/drivers/FakeInstrument.py

@@ -1,4 +1,6 @@
-from waveforms.sys.device import BaseDevice, exclude, get, set
+import numpy as np
+
+from qulab.sys import BaseDevice, exclude, get, set
 
 
 class Device(BaseDevice):
@@ -12,41 +14,55 @@ class Device(BaseDevice):
     def get_idn(self) -> str:
         return 'Fake Instrument'
 
-    @set('{channel}.Vpp', channel=exclude(['M1', 'M2']))
+    @get('${channel_type}${channel_num}.SampleRate',
+         channel_type=['X', 'Y'],
+         channel_num=[1, 2, 3, 4])
+    def get_sample_rate_DDS(self, channel_type: str,
+                            channel_num: int) -> float:
+        return 6e9
+
+    @get('${channel}.SampleRate', channel=['Z1', 'Z2', 'Z3', 'Z4'])
+    def get_sample_rate_Z(self, channel: str) -> float:
+        return 2e9
+
+    @get('${channel}.SampleRate', channel=['M1', 'M2'])
+    def get_sample_rate_AD(self, channel: str) -> float:
+        return 1e9
+
+    @set('${channel}.Vpp', channel=exclude(['M1', 'M2']))
     def set_voltage(self, value: float, channel: str) -> None:
         self.log.info(f'Set {channel} Vpp to {value}')
 
-    @get('{channel}.Vpp', channel=exclude(['M1', 'M2']))
-    def get_voltage(self, channel: str, default=0.0) -> float:
-        return self._status.get(f'{channel}.Vpp', default)
+    # @get('${channel}.Vpp', channel=exclude(['M1', 'M2']))
+    # def get_voltage(self, channel: str, default=0.0) -> float:
+    #     return self._state.get(f'{channel}.Vpp', default)
 
-    @set('{channel}.Offset', channel=exclude(['M1', 'M2']))
-    def set_frequency(
+    @set('${channel}.Offset', channel=exclude(['M1', 'M2']))
+    def set_offset(
         self,
         value: float,
         channel: str,
     ) -> None:
         self.log.info(f'Set {channel} offset to {value}')
 
-    @get('{channel}.Offset', channel=exclude(['M1', 'M2']))
-    def get_frequency(self, channel: str, default=0.0) -> float:
-        return self._status.get(f'{channel}.Offset', default)
+    # @get('${channel}.Offset', channel=exclude(['M1', 'M2']))
+    # def get_offset(self, channel: str, default=0.0) -> float:
+    #     return self._state.get(f'{channel}.Offset', default)
 
-    @set('{channel}.Waveform', channel=exclude(['M1', 'M2']))
+    @set('${channel}.Waveform', channel=exclude(['M1', 'M2']))
     def set_waveform(self, value, channel: str) -> None:
         self.log.info(f'Set {channel} waveform to {value!r}')
 
-    @get('{channel}.Waveform', channel=exclude(['M1', 'M2']))
-    def get_waveform(self, channel: str, default=None) -> str:
-        return self._status.get(f'{channel}.Waveform', default)
+    # @get('${channel}.Waveform', channel=exclude(['M1', 'M2']))
+    # def get_waveform(self, channel: str, default=None) -> str:
+    #     return self._state.get(f'{channel}.Waveform', default)
 
-    @set('{channel}.Size', channel=['M1', 'M2'])
+    @set('${channel}.Size', channel=['M1', 'M2'])
     def set_size(self, value, channel: str) -> None:
         self.log.info(f'Set {channel} size to {value!r}')
 
-    @get('{channel}.Trace', channel=['M1', 'M2'])
-    def get_size(self, channel: str) -> str:
-        import numpy as np
-        size = self._status.get(f'{channel}.Size', 1024)
-        shots = self._status.get(f'{channel}.Shots', 128)
+    @get('${channel}.Trace', channel=['M1', 'M2'])
+    def get_random_data(self, channel: str) -> np.ndarray:
+        size = self._state.get(f'{channel}.Size', 1024)
+        shots = self._state.get(f'{channel}.Shots', 128)
         return np.random.randn(shots, size)

qulab/sys/net/nginx.py

@@ -6,6 +6,9 @@ from fastapi import FastAPI, Request
 from fastapi.responses import Response
 from pydantic import BaseModel
 
+NGINX_DIR = 'C:/Users/Administrator/Desktop/nginx/nginx-1.20.2'
+HOST_URL = 'https://systemq.baqis.ac.cn'
+
 db = {
     "n01": {
         "notebook_port": 1000,
@@ -28,7 +31,8 @@ db = {
 }
 
 
-def fmt_config(ip, notebook_port, codeserver_port, local_notebook_port, local_codeserver_port, page):
+def fmt_config(ip, notebook_port, codeserver_port, local_notebook_port,
+               local_codeserver_port, page):
     return """
 server {""" + f"""
     listen {notebook_port} ssl;
@@ -108,6 +112,7 @@ server {""" + f"""
 }
 """
 
+
 def fmt_page(notebook_url, codeserver_url):
     return """
 <!DOCTYPE html>
@@ -142,7 +147,7 @@ class Node(BaseModel):
 app = FastAPI()
 
 
-@app.post("/ping")
+@app.post("/auth")
 async def auth(request: Request, node: Node):
     try:
         assert node.name in db
@@ -156,34 +161,31 @@ async def auth(request: Request, node: Node):
         else:
             print("    CHANGE IP", db[node.name]['ip'], "===>", ip)
             db[node.name]['ip'] = ip
-        
+
         #ip = request.headers.get('x-real-ip')
         local_notebook_port = node.notebook_port
         local_codeserver_port = node.codeserver_port
         codeserver_path = quote_plus(node.codeserver_path)
 
-        codeserver_url = f"https://systemq.baqis.ac.cn:{codeserver_port}?tkn=lZBAQISFF532&folder={codeserver_path}"
-        notebook_url = f"https://systemq.baqis.ac.cn:{notebook_port}/tree"
+        codeserver_url = f"{HOST_URL}:{codeserver_port}?tkn=lZBAQISFF532&folder={codeserver_path}"
+        notebook_url = f"{HOST_URL}:{notebook_port}/tree"
 
         page = fmt_page(notebook_url, codeserver_url)
         page = ''.join(page.splitlines())
 
-        config = fmt_config(ip, notebook_port, codeserver_port, local_notebook_port, local_codeserver_port, page)
+        config = fmt_config(ip, notebook_port, codeserver_port,
+                            local_notebook_port, local_codeserver_port, page)
 
-        with open(
-                f"C:/Users/Administrator/Desktop/nginx/nginx-1.20.2/conf/servers/{node.name}.conf",
-                "w") as f:
+        with open(f"{NGINX_DIR}/conf/servers/{node.name}.conf", "w") as f:
             f.write(config)
 
         await asyncio.sleep(0.1)
-        
+
         cwd = os.getcwd()
 
-        os.chdir(r'C:\Users\Administrator\Desktop\nginx\nginx-1.20.2')
+        os.chdir(NGINX_DIR)
 
-        os.system(
-            r'C:\Users\Administrator\Desktop\nginx\nginx-1.20.2\nginx.exe -s reload'
-        )
+        os.system(f'{NGINX_DIR}/nginx.exe -s reload')
 
         os.chdir(cwd)