QuLab 2.10.10__cp313-cp313-macosx_10_13_universal2.whl

qulab/scan/utils.py

@@ -0,0 +1,234 @@
+import ast
+import asyncio
+import inspect
+import platform
+import re
+import subprocess
+import sys
+import uuid
+import warnings
+from typing import Any, Callable
+
+import dill
+
+from ..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:
+        ret = dill.loads(buff)
+    except:
+        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/storage/__main__.py

@@ -0,0 +1,51 @@
+import click
+
+
+@click.command()
+@click.option('--executor', default='', help='Executor address to use.')
+@click.option('--port', default=8080, help='Port to run the server on.')
+@click.option('--host', default='127.0.0.1', help='Host to run the server on.')
+@click.option('--db-url', default=None, help='Database URL to use.')
+@click.option('--data-path',
+              default='waveforms/data',
+              help='Path to the data directory.')
+@click.option('--debug', is_flag=True, help='Run in debug mode.')
+@click.option('--workers',
+              default=1,
+              help='Number of workers to run the server with.')
+@click.option('--timeout', default=60, help='Timeout for requests.')
+@click.option('--log-level',
+              default='INFO',
+              help='Log level to run the server with.')
+@click.option('--log-file',
+              default='/var/log/waveforms/server.log',
+              help='Log file to run the server with.')
+@click.option('--log-format',
+              default='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+              help='Log format to run the server with.')
+def main(executor, port, host, db_url, data_path, debug, workers, timeout,
+         log_level, log_file, log_format):
+    """
+    Main entry point for the server.
+    """
+    from waveforms.server import create_app
+
+    app = create_app(
+        executor=executor,
+        port=port,
+        host=host,
+        db_url=db_url,
+        data_path=data_path,
+        debug=debug,
+        workers=workers,
+        timeout=timeout,
+        log_level=log_level,
+        log_file=log_file,
+        log_format=log_format,
+    )
+    app.run()
+
+
+if __name__ == '__main__':
+    main()
+    

qulab/storage/backend/redis.py

@@ -0,0 +1,204 @@
+import dill
+import numpy as np
+import redis
+
+
+def try_dumps(value):
+    try:
+        value_b = dill.dumps(value)
+    except:
+        value_b = dill.dumps(str(value))
+    finally:
+        return value_b
+
+
+class redisClient(object):
+
+    def __init__(self,
+                 name,
+                 server=None,
+                 addr='redis://localhost:6379/0',
+                 expire_time=172800):
+        self._r = redis.Redis.from_url(addr) if server is None else server
+        self.name = name
+        self.expire_time = int(expire_time)  # 默认数据两天过期，单位秒
+
+    def delete(self):
+        self._r.delete(self.name)
+
+
+class redisString(redisClient):
+    '''Redis String client'''
+
+    def set(self, value):
+        if value is not None:
+            value_b = try_dumps(value)
+            self._r.set(self.name, value_b, ex=self.expire_time)
+
+    def get(self):
+        v_b = self._r.get(self.name)
+        value = dill.loads(v_b) if v_b is not None else None
+        return value
+
+    @property
+    def data(self):
+        return self.get()
+
+
+class redisList(redisClient):
+    '''Redis List client'''
+
+    def add(self, *arg):
+        arg_b = [dill.dumps(i) for i in arg]
+        self._r.rpush(self.name, *arg_b)
+        self._r.expire(self.name, self.expire_time)
+
+    def read(self, start=0, end=-1):
+        data_b = self._r.lrange(self.name, start, end)
+        data = [dill.loads(i) for i in data_b]
+        return data
+
+    @property
+    def size(self):
+        return self._r.llen(self.name)
+
+    @property
+    def data(self):
+        return self.read()
+
+
+class redisSet(redisClient):
+    '''Redis Set client'''
+
+    def add(self, *arg):
+        arg_b = {dill.dumps(i) for i in arg}
+        self._r.sadd(self.name, *arg_b)
+        self._r.expire(self.name, self.expire_time)
+
+    def read(self):
+        data_b = self._r.smembers(self.name)
+        data = {dill.loads(i) for i in data_b}
+        return data
+
+    @property
+    def size(self):
+        return self._r.scard(self.name)
+
+    @property
+    def data(self):
+        return self.read()
+
+
+class redisZSet(redisClient):
+    '''有序集合'''
+
+    def __init__(self,
+                 name,
+                 server=None,
+                 addr='redis://localhost:6379/0',
+                 expire_time=172800):
+        super().__init__(name, server, addr, expire_time)
+        self.__score = 0
+
+    def delete(self):
+        super().delete()
+        self.__score = 0
+
+    def add(self, *elements):
+        mapping = {}
+        for ele in elements:
+            ele_b = dill.dumps(ele)
+            self.__score += 1
+            mapping.update({ele_b: self.__score})
+        self._r.zadd(self.name, mapping, nx=True)  # 只添加新元素
+        self._r.expire(self.name, self.expire_time)
+
+    def read(self, start=0, end=-1):
+        data_b = self._r.zrange(self.name, start, end, withscores=False)
+        data = [dill.loads(i) for i in data_b]
+        return data
+
+    @property
+    def size(self):
+        return self._r.zcard(self.name)
+
+    @property
+    def data(self):
+        return self.read()
+
+
+class redisHash(redisClient):
+    '''Redis Hash client'''
+
+    def add(self, **kw):
+        kw_b = {k: try_dumps(v) for k, v in kw.items()}
+        self._r.hmset(self.name, kw_b)
+        self._r.expire(self.name, self.expire_time)
+
+    def read(self):
+        data_b = self._r.hgetall(self.name)
+        data = {k_b.decode(): dill.loads(v_b) for k_b, v_b in data_b.items()}
+        return data
+
+    def get(self, key):
+        '''读取Hash中的一个key'''
+        v_b = self._r.hget(self.name, key)
+        value = dill.loads(v_b) if v_b is not None else None
+        return value
+
+    @property
+    def size(self):
+        return self._r.hlen(self.name)
+
+    @property
+    def data(self):
+        return self.read()
+
+
+class redisArray(redisClient):
+    '''Redis np.array client'''
+
+    def __init__(self,
+                 name,
+                 server=None,
+                 addr='redis://localhost:6379/0',
+                 expire_time=172800,
+                 dtype='complex128'):
+        super().__init__(name, server, addr, expire_time)
+        _r_dtype = self._r.get(f'{name}.dtype')
+        if _r_dtype is None:
+            self._r.set(f'{name}.dtype', dtype, ex=self.expire_time)
+            self.dtype = dtype
+        else:
+            self.dtype = _r_dtype
+
+    def delete(self):
+        self._r.delete(self.name)
+        self._r.delete(f'{self.name}.dtype')
+
+    def add(self, *args):
+        for arg in args:
+            buf = np.asarray(arg).astype(self.dtype).tobytes()
+            # self._r.append(self.name, buf)
+            self._r.rpush(self.name, buf)
+        self._r.expire(self.name, self.expire_time)
+
+    def read(self):
+        # buf = self._r.get(self.name)
+        buf_list = self._r.lrange(self.name, 0, -1)
+        buf = b''.join(buf_list)
+        data = np.frombuffer(buf,
+                             dtype=self.dtype) if buf is not None else None
+        return data
+
+    @property
+    def size(self):
+        array = self.data
+        if array is None:
+            return 0
+        else:
+            return array.size
+
+    @property
+    def data(self):
+        return self.read()