QuLab 2.0.1__cp310-cp310-win_amd64.whl

qulab/scan/scanner.py

@@ -0,0 +1,270 @@
+import ast
+import itertools
+
+import numpy as np
+
+from .base import scan_iters
+from .expression import Env, Expression, Symbol, _empty
+
+
+def is_valid_identifier(s: str) -> bool:
+    try:
+        ast.parse(f"f({s}=0)")
+        return True
+    except SyntaxError:
+        return False
+
+
+class Atom():
+    __slots__ = ('value', )
+
+    def __init__(self, value):
+        self.value = value
+
+
+class MappedSymbol(Symbol):
+    pass
+
+
+class OptimizeSpace():
+
+    def __init__(self, optimizer, space):
+        self.optimizer = optimizer
+        self.space = space
+        self.name = None
+
+
+class Optimizer():
+
+    def __init__(self, cls, *args, **kwds):
+        self.cls = cls
+        self.args = args
+        self.kwds = kwds
+        self.dimensions = {}
+        self.function = None
+
+    def Categorical(self, *args, **kwds):
+        from skopt.space import Categorical
+        return OptimizeSpace(self, Categorical(*args, **kwds))
+
+    def Integer(self, *args, **kwds):
+        from skopt.space import Integer
+        return OptimizeSpace(self, Integer(*args, **kwds))
+
+    def Real(self, *args, **kwds):
+        from skopt.space import Real
+        return OptimizeSpace(self, Real(*args, **kwds))
+
+    @property
+    def target(self):
+        return None
+
+    @target.setter
+    def target(self, fun):
+        if isinstance(fun, Symbol):
+            self.function = fun.name
+        elif isinstance(fun, Expression):
+            self.function = fun
+        else:
+            raise ValueError("Invalid function")
+
+    def create_optimizer(self):
+        dimensions = list(self.dimensions.values())
+        return tuple(self.dimensions.keys()), self.cls(dimensions, *self.args,
+                                                       **self.kwds)
+
+
+class Action():
+
+    __slots__ = ('name', 'args', 'kwds')
+
+    def __init__(self, name, *args, **kwds):
+        self.name = name
+        self.args = args
+        self.kwds = kwds
+
+    def __repr__(self):
+        return f"Action({self.name!r}, {self.args}, {self.kwds})"
+
+
+class Scan():
+
+    def __new__(cls, *args, mixin=None, **kwds):
+        if mixin is None:
+            return super().__new__(cls)
+        for k in dir(mixin):
+            if not hasattr(cls, k):
+                try:
+                    setattr(cls, k, getattr(mixin, k))
+                except:
+                    pass
+        return super().__new__(cls)
+
+    def __init__(self, name, *args, env=None, mixin=None, **kwds):
+        super().__init__(*args, **kwds)
+        self._name = name.replace(' ', '_')
+        self.env = Env() if env is None else env
+        self.functions = {}
+        self.consts = {}
+        self.loops = {}
+        self.mapping = {}
+        self.optimizers = {}
+        self._mapping_i = 0
+        self.filter = None
+        self.scan_info = {'loops': {}}
+        self._tmp = {}
+        self.actions = {}
+        self.iteration = 0
+
+    @property
+    def name(self):
+        return f"Scan.{self._name}"
+
+    def get(self, key, default=_empty):
+        if key in self.consts:
+            return self.consts[key]
+        if key in self.functions:
+            return self.functions[key]
+        if default is _empty:
+            raise KeyError(f"Key {key} not found")
+        return default
+
+    def set(self, key, value):
+        self.add_action(Action('set', key, value))
+
+    def _mapping(self, key, value):
+        tmpkey = f"__tmp_{self._mapping_i}__"
+        self._mapping_i += 1
+        self.__setitem(tmpkey, value)
+        self.mapping[key] = tmpkey
+
+    def __setitem__(self, key, value):
+        if is_valid_identifier(key):
+            if isinstance(value, Atom):
+                self.consts[key] = value.value
+                return
+            elif isinstance(value, (str, int, float, complex, tuple)):
+                self.consts[key] = value
+                return
+
+        if isinstance(value, Expression):
+            env = Env()
+            env.consts = self.consts
+            value = value.value(env)
+            if not isinstance(value, Expression):
+                self.__setitem__(key, value)
+                return
+
+        self._tmp[key] = value
+
+    def __setitem(self, key, value):
+        if not is_valid_identifier(key):
+            self._mapping(key, value)
+            return
+        if isinstance(value, Expression) or callable(value):
+            self.functions[key] = value
+        elif isinstance(value, OptimizeSpace):
+            self.optimizers[key] = value.optimizer
+            value.name = key
+            value.optimizer.dimensions[key] = value.space
+            self.loops[key] = value.optimizer
+        elif isinstance(value, (np.ndarray, list, range)):
+            self.loops[key] = value
+        elif isinstance(value, Atom):
+            self.consts[key] = value.value
+        else:
+            self.consts[key] = value
+
+    def __getitem__(self, key):
+        if key in self.consts:
+            return self.consts[key]
+        if is_valid_identifier(key):
+            return Symbol(key)
+        else:
+            if key in self.mapping:
+                return Symbol(self.mapping[key])
+            return MappedSymbol(key)
+
+    def assemble(self):
+        for key, value in self._tmp.items():
+            self.__setitem(key, value)
+
+        variables = {}
+        loops = {}
+
+        for k, v in self.functions.items():
+            if isinstance(v, MappedSymbol):
+                variables[k] = eval(
+                    f"lambda {self.mapping[k]}: {self.mapping[k]}")
+            elif isinstance(v, Expression):
+                args = v.symbols()
+                for x in args:
+                    if x in self.mapping:
+                        args.remove(x)
+                        v = v.value({x: Symbol(self.mapping[x])})
+                        x = self.mapping[x]
+                    if x in self.consts:
+                        args.remove(x)
+                        v = v.value({x: self.consts[x]})
+                if args:
+                    variables[k] = eval(
+                        f"lambda {','.join(args)}: expr.value({{{','.join([f'{x!r}:{x}' for x in args])}}})",
+                        {'expr': v})
+                else:
+                    self.consts[k] = v
+            else:
+                variables[k] = v
+
+        for key, value in self.loops.items():
+            if isinstance(value, Optimizer):
+                #variables[key] = value.create_optimizer()
+                pass
+            else:
+                loops[key] = value
+
+        self.scan_info = {
+            'loops': loops,
+            'functions': variables,
+            'constants': self.consts
+        }
+
+        if self.filter is not None:
+            self.scan_info['filter'] = self.filter
+
+    def main(self):
+        self.assemble()
+        for step in self.scan():
+            for k, v in self.mapping.items():
+                if v in set(
+                        itertools.chain.from_iterable(
+                            step.vars[step.unchanged:])
+                ) or step.iteration == 0:
+                    self.set(k, step.kwds[v])
+            self.process(step)
+
+    def process(self, step):
+        for k, v in step.kwds.items():
+            if not k.startswith('__tmp_') and not k.startswith('__'):
+                self.add_action(Action('write', k, v))
+
+    def scan(self):
+        for step in scan_iters(**self.scan_info):
+            for k, v in self.mapping.items():
+                step.kwds[k] = step.kwds[v]
+            yield step
+            self.iteration += 1
+
+    def add_action(self, action: Action):
+        self.actions.setdefault(self.iteration, []).append(action)
+
+    def run(self, dry_run=False):
+        pass
+
+    def plot(self,
+             result=None,
+             fig=None,
+             axis=None,
+             data='population',
+             T=False,
+             **kwds):
+        pass

qulab/scan/transforms.py

@@ -0,0 +1,16 @@
+class Aggregation():
+
+    def __init__(self):
+        pass
+
+    def __call__(self, data):
+        raise NotImplementedError()
+
+
+class Transform():
+
+    def __init__(self):
+        pass
+
+    def __call__(self, data):
+        raise NotImplementedError()

qulab/scan/utils.py

@@ -0,0 +1,37 @@
+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):]
+    }
+    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)
+    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

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()