QuLab 2.0.2__cp310-cp310-win_amd64.whl → 2.0.3__cp310-cp310-win_amd64.whl

{QuLab-2.0.2.dist-info → QuLab-2.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: QuLab
-Version: 2.0.2
+Version: 2.0.3
 Summary: contral instruments and manage data
 Author-email: feihoo87 <feihoo87@gmail.com>
 Maintainer-email: feihoo87 <feihoo87@gmail.com>
@@ -32,6 +32,7 @@ Requires-Dist: ipython >=7.4.0
 Requires-Dist: ipywidgets >=7.4.2
 Requires-Dist: loguru >=0.7.2
 Requires-Dist: matplotlib >=3.7.2
+Requires-Dist: nevergrad >=1.0.2
 Requires-Dist: numpy >=1.13.3
 Requires-Dist: ply >=3.11
 Requires-Dist: pyzmq >=25.1.0

{QuLab-2.0.2.dist-info → QuLab-2.0.3.dist-info}/RECORD

@@ -1,7 +1,7 @@
 qulab/__init__.py,sha256=8zLGg-DfQhnDl2Ky0n-zXpN-8e-g7iR0AcaI4l4Vvpk,32
 qulab/__main__.py,sha256=OlYQe7go_eFLKR0uU6D1kIpTKvbpx3WRJFFdoYoFjdE,456
-qulab/fun.cp310-win_amd64.pyd,sha256=MZNJeG9X3CwTwSA8OwNz20kasnjWb9ldNTTRnmhTpAo,31232
-qulab/version.py,sha256=xARS6PXiulA1Bog5UZUM6hqQfydeRzKLyWtOyUBL-Ss,21
+qulab/fun.cp310-win_amd64.pyd,sha256=fmKTeNwow5U3R6yqIbv77flyO5b9_60K9FdOyY2OVxc,31232
+qulab/version.py,sha256=HFL2NgNf74s56viRPRlgp_rAmKP1MzrtnJeQ8LxF_8M,21
 qulab/monitor/__init__.py,sha256=xEVDkJF8issrsDeLqQmDsvtRmrf-UiViFcGTWuzdlFU,43
 qulab/monitor/__main__.py,sha256=k2H1H5Zf9LLXTDLISJkbikLH-z0f1e5i5i6wXXYPOrE,105
 qulab/monitor/config.py,sha256=y_5StMkdrbZO1ziyKBrvIkB7Jclp9RCPK1QbsOhCxnY,785
@@ -19,8 +19,8 @@ qulab/scan/models.py,sha256=TkiVHF_fUZzYHs4MsCTRh391thpf4Ozd3R_LAU0Gxkg,17657
 qulab/scan/optimize.py,sha256=MlT4y422CnP961IR384UKryyZh8riNvrPSd2z_MXLEg,2356
 qulab/scan/query_record.py,sha256=gRUBjablvjWhDM-nZEunMVxQbUeaFF8qG7sROy9kIbs,11882
 qulab/scan/recorder.py,sha256=EgS7NzARFqZeWUJp188iFQWr-_fa7Akm0Op-tvGqh7A,15849
-qulab/scan/scan.py,sha256=1hfnV4TpGPw-EtBzoMorqAjulDG6WrjX3y5lUBbI7YE,23731
-qulab/scan/utils.py,sha256=DHGC-RcGbY7RmMEDvazPkC_nFqlj_N8Cr9spm_CGfuE,1061
+qulab/scan/scan.py,sha256=jDsjyOPf15DV8rk1q2CYH7aDO6ypaP6n7t3LmNaY03o,23187
+qulab/scan/utils.py,sha256=XM-eKL5Xkm0hihhGS7Kq4g654Ye7n7TcU_f95gxtXq8,2634
 qulab/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/storage/__main__.py,sha256=6-EjN0waX1yfcMPJXqpIr9UlrIEsSCFApm5G-ZeaPMQ,1742
 qulab/storage/base_dataset.py,sha256=28y3-OZrqJ52p5sbirEpUgjb7hqwLLpd38KU9DCkD24,12217
@@ -76,9 +76,9 @@ qulab/visualization/plot_layout.py,sha256=yAnMONOms7_szCdng-8wPpUMPis5UnbaNNzV4K
 qulab/visualization/plot_seq.py,sha256=h9D0Yl_yO64IwlvBgzMu9EBKr9gg6y8QE55gu2PfTns,2783
 qulab/visualization/qdat.py,sha256=HubXFu4nfcA7iUzghJGle1C86G6221hicLR0b-GqhKQ,5887
 qulab/visualization/widgets.py,sha256=HcYwdhDtLreJiYaZuN3LfofjJmZcLwjMfP5aasebgDo,3266
-QuLab-2.0.2.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
-QuLab-2.0.2.dist-info/METADATA,sha256=4OR_9ZAdwX58Fsqa5EVFdtZWRfVn2YiHHlG01SZrmoU,3575
-QuLab-2.0.2.dist-info/WHEEL,sha256=lO6CqtLHCAi38X3Es1a4R1lAjZFvN010IMRCFo2S7Mc,102
-QuLab-2.0.2.dist-info/entry_points.txt,sha256=ohBzutEnQimP_BZWiuXdSliu4QAYSHHcN0PZD8c7ZCY,46
-QuLab-2.0.2.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-QuLab-2.0.2.dist-info/RECORD,,
+QuLab-2.0.3.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
+QuLab-2.0.3.dist-info/METADATA,sha256=CBLJJtH8PMO1np50hxS8-Xbs1Bj4lFN1T7AwYCFI47Q,3609
+QuLab-2.0.3.dist-info/WHEEL,sha256=lO6CqtLHCAi38X3Es1a4R1lAjZFvN010IMRCFo2S7Mc,102
+QuLab-2.0.3.dist-info/entry_points.txt,sha256=ohBzutEnQimP_BZWiuXdSliu4QAYSHHcN0PZD8c7ZCY,46
+QuLab-2.0.3.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+QuLab-2.0.3.dist-info/RECORD,,

qulab/scan/scan.py

@@ -1,13 +1,15 @@
-import ast
 import asyncio
+import datetime
 import inspect
 import itertools
+import os
+import re
 import sys
 import uuid
 from graphlib import TopologicalSorter
 from pathlib import Path
 from types import MethodType
-from typing import Any, Callable, Type
+from typing import Any, Awaitable, Callable, Iterable, Type
 
 import dill
 import numpy as np
@@ -20,72 +22,14 @@ from ..sys.rpc.zmq_socket import ZMQContextManager
 from .expression import Env, Expression, Symbol
 from .optimize import NgOptimizer
 from .recorder import Record
+from .utils import async_zip, call_function
 
+__process_uuid = uuid.uuid1()
+__task_counter = itertools.count()
 
-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
-
-
-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
+def task_uuid():
+    return uuid.uuid3(__process_uuid, str(next(__task_counter)))
 
 
 def _get_depends(func: Callable):
@@ -108,17 +52,6 @@ def _get_depends(func: Callable):
     return args
 
 
-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
-
-
 class OptimizeSpace():
 
     def __init__(self, optimizer: 'Optimizer', space):
@@ -224,11 +157,23 @@ class Promise():
 
 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,
                  app: str = 'task',
                  tags: tuple[str] = (),
-                 database: str | Path | None = 'tcp://127.0.0.1:6789'):
-        self.id = f"{app}({str(uuid.uuid1())})"
+                 database: str | Path | None = 'tcp://127.0.0.1:6789',
+                 mixin=None):
+        self.id = task_uuid()
         self.record = None
         self.namespace = {}
         self.description = {
@@ -242,17 +187,18 @@ class Scan():
             'dependents': {},
             'order': {},
             'filters': {},
-            'total': {},
-            'compiled': False,
+            'total': {}
         }
         self._current_level = 0
         self.variables = {}
         self._task = None
         self.sock = None
         self.database = database
-        self._variables = {}
         self._sem = asyncio.Semaphore(100)
-        self._bar = {}
+        self._bar: dict[int, tqdm] = {}
+        self._hide_patterns = [r'^__.*', r'.*__$']
+        self._hide_pattern_re = re.compile('|'.join(self._hide_patterns))
+        self._task_queue = asyncio.Queue()
 
     def __getstate__(self) -> dict:
         state = self.__dict__.copy()
@@ -278,7 +224,7 @@ class Scan():
     async def emit(self, current_level, step, position, variables: dict[str,
                                                                         Any]):
         for key, value in list(variables.items()):
-            if inspect.isawaitable(value):
+            if inspect.isawaitable(value) and not self.hiden(key):
                 variables[key] = await value
         if self.sock is not None:
             await self.sock.send_pyobj({
@@ -288,11 +234,21 @@ class Scan():
                 'level': current_level,
                 'step': step,
                 'position': position,
-                'variables': variables
+                'variables': {
+                    k: v
+                    for k, v in variables.items() if not self.hiden(k)
+                }
             })
         else:
             self.record.append(current_level, step, position, variables)
 
+    def hide(self, name: str):
+        self._hide_patterns.append(re.compile(name))
+        self._hide_pattern_re = re.compile('|'.join(self._hide_patterns))
+
+    def hiden(self, name: str) -> bool:
+        return bool(self._hide_pattern_re.match(name))
+
     async def _filter(self, variables: dict[str, Any], level: int = 0):
         try:
             return all([
@@ -317,6 +273,9 @@ class Scan():
             except:
                 scripts = ('', [])
 
+        self.description['ctime'] = datetime.datetime.now()
+        self.description['scripts'] = scripts
+        self.description['env'] = {k: v for k, v in os.environ.items()}
         if self.sock is not None:
             await self.sock.send_pyobj({
                 'task':
@@ -324,12 +283,7 @@ class Scan():
                 'method':
                 'record_create',
                 'description':
-                dill.dumps(self.description),
-                # 'env':
-                # dill.dumps(__main__.__dict__),
-                'scripts':
-                scripts,
-                'tags': []
+                dill.dumps(self.description)
             })
 
             record_id = await self.sock.recv_pyobj()
@@ -356,7 +310,7 @@ class Scan():
             self.description['dependents'][name] = set()
         self.description['dependents'][name].update(depends)
 
-    def add_filter(self, func, level):
+    def add_filter(self, func: Callable, level: int):
         """
         Add a filter function to the scan.
 
@@ -427,8 +381,17 @@ class Scan():
         self.description['optimizers'][name] = opt
         return opt
 
+    async def _update_progress(self):
+        while True:
+            task = await self._task_queue.get()
+            if isinstance(task, asyncio.Event):
+                task.set()
+            elif inspect.isawaitable(task):
+                await task
+
     async def _run(self):
-        self.assymbly()
+        assymbly(self.description)
+        task = asyncio.create_task(self._update_progress())
         self.variables = self.description['consts'].copy()
         for level, total in self.description['total'].items():
             if total == np.inf:
@@ -451,6 +414,7 @@ class Scan():
             await self.work()
         for level, bar in self._bar.items():
             bar.close()
+        task.cancel()
         return self.variables
 
     async def done(self):
@@ -468,171 +432,13 @@ class Scan():
         if self._task is not None:
             self._task.cancel()
 
-    def assymbly(self):
-        if self.description['compiled']:
-            return
-
-        mapping = {
-            label: level
-            for level, label in enumerate(
-                sorted(
-                    set(self.description['loops'].keys())
-                    | set(self.description['actions'].keys()) - {-1}))
-        }
+    async def _reset_progress_bar(self, level):
+        if level in self._bar:
+            self._bar[level].reset()
 
-        if -1 in self.description['actions']:
-            mapping[-1] = max(mapping.values()) + 1
-
-        self.description['loops'] = dict(
-            sorted([(mapping[k], v)
-                    for k, v in self.description['loops'].items()]))
-        self.description['actions'] = {
-            mapping[k]: v
-            for k, v in self.description['actions'].items()
-        }
-
-        for level, loops in self.description['loops'].items():
-            self.description['total'][level] = np.inf
-            for name, space in loops:
-                try:
-                    self.description['total'][level] = min(
-                        self.description['total'][level], len(space))
-                except:
-                    pass
-
-        dependents = self.description['dependents'].copy()
-
-        for level in range(len(mapping)):
-            range_list = self.description['loops'].get(level, [])
-            if level > 0:
-                if f'#__loop_{level}' not in self.description['dependents']:
-                    dependents[f'#__loop_{level}'] = []
-                dependents[f'#__loop_{level}'].append(f'#__loop_{level-1}')
-            for name, _ in range_list:
-                if name not in self.description['dependents']:
-                    dependents[name] = []
-                dependents[name].append(f'#__loop_{level}')
-
-        def _get_all_depends(key, graph):
-            ret = set()
-            if key not in graph:
-                return ret
-
-            for e in graph[key]:
-                ret.update(_get_all_depends(e, graph))
-            ret.update(graph[key])
-            return ret
-
-        full_depends = {}
-        for key in dependents:
-            full_depends[key] = _get_all_depends(key, dependents)
-
-        levels = {}
-        passed = set()
-        all_keys = set()
-        for level in reversed(self.description['loops'].keys()):
-            tag = f'#__loop_{level}'
-            for key, deps in full_depends.items():
-                all_keys.update(deps)
-                all_keys.add(key)
-                if key.startswith('#__loop_'):
-                    continue
-                if tag in deps:
-                    if level not in levels:
-                        levels[level] = set()
-                    if key not in passed:
-                        passed.add(key)
-                        levels[level].add(key)
-        levels[-1] = {
-            key
-            for key in all_keys - passed if not key.startswith('#__loop_')
-        }
-
-        order = []
-        ts = TopologicalSorter(dependents)
-        ts.prepare()
-        while ts.is_active():
-            ready = ts.get_ready()
-            order.append(ready)
-            for k in ready:
-                ts.done(k)
-
-        self.description['order'] = {}
-
-        for level in sorted(levels):
-            keys = set(levels[level])
-            self.description['order'][level] = []
-            for ready in order:
-                ready = list(keys & set(ready))
-                if ready:
-                    self.description['order'][level].append(ready)
-                    keys -= set(ready)
-
-        self.description['compiled'] = True
-
-    async def _iter_level(self, level, variables):
-        iters = {}
-        env = Env()
-        env.variables = variables
-        opts = {}
-
-        for name, iter in self.description['loops'][level]:
-            if isinstance(iter, OptimizeSpace):
-                if iter.optimizer.name not in opts:
-                    opts[iter.optimizer.name] = iter.optimizer.create()
-            elif isinstance(iter, Expression):
-                iters[name] = iter.eval(env)
-            elif callable(iter):
-                iters[name] = await call_function(iter, variables)
-            else:
-                iters[name] = iter
-
-        maxiter = 0xffffffff
-        for name, opt in opts.items():
-            opt_cfg = self.description['optimizers'][name]
-            maxiter = min(maxiter, opt_cfg.maxiter)
-
-        async for args in async_zip(*iters.values(), range(maxiter)):
-            variables.update(dict(zip(iters.keys(), args[:-1])))
-            for name, opt in opts.items():
-                args = opt.ask()
-                opt_cfg = self.description['optimizers'][name]
-                variables.update({
-                    n: v
-                    for n, v in zip(opt_cfg.dimensions.keys(), args)
-                })
-
-            for group in self.description['order'].get(level, []):
-                for name in group:
-                    if name in self.description['functions']:
-                        variables[name] = await call_function(
-                            self.description['functions'][name], variables)
-
-            yield variables
-
-            for name, opt in opts.items():
-                opt_cfg = self.description['optimizers'][name]
-                args = [variables[n] for n in opt_cfg.dimensions.keys()]
-                if name not in variables:
-                    raise ValueError(f'{name} not in variables.')
-                fun = variables[name]
-                if inspect.isawaitable(fun):
-                    fun = await fun
-                if opt_cfg.minimize:
-                    opt.tell(args, fun)
-                else:
-                    opt.tell(args, -fun)
-
-        for name, opt in opts.items():
-            opt_cfg = self.description['optimizers'][name]
-            result = opt.get_result()
-            variables.update({
-                n: v
-                for n, v in zip(opt_cfg.dimensions.keys(), result.x)
-            })
-            variables[name] = result.fun
-        if opts:
-            yield variables
+    async def _update_progress_bar(self, level, n: int):
+        if level in self._bar:
+            self._bar[level].update(n)
 
     async def iter(self, **kwds):
         if self.current_level >= len(self.description['loops']):
@@ -640,10 +446,13 @@ class Scan():
         step = 0
         position = 0
         task = None
-        if self.current_level in self._bar:
-            self._bar[self.current_level].reset()
-        async for variables in self._iter_level(self.current_level,
-                                                self.variables):
+        self._task_queue.put_nowait(
+            self._reset_progress_bar(self.current_level))
+        async for variables in _iter_level(
+                self.variables,
+                self.description['loops'].get(self.current_level, []),
+                self.description['order'].get(self.current_level, []),
+                self.description['functions'], self.description['optimizers']):
             self._current_level += 1
             if await self._filter(variables, self.current_level - 1):
                 yield variables
@@ -653,12 +462,19 @@ class Scan():
                 step += 1
             position += 1
             self._current_level -= 1
-            if self.current_level in self._bar:
-                self._bar[self.current_level].update(1)
+            self._task_queue.put_nowait(
+                self._update_progress_bar(self.current_level, 1))
         if task is not None:
             await task
         if self.current_level == 0:
             await self.emit(self.current_level - 1, 0, 0, {})
+            for name, value in self.variables.items():
+                if inspect.isawaitable(value):
+                    self.variables[name] = await value
+            while not self._task_queue.empty():
+                task = self._task_queue.get_nowait()
+                if inspect.isawaitable(task):
+                    await task
 
     async def work(self, **kwds):
         if self.current_level in self.description['actions']:
@@ -683,7 +499,7 @@ class Scan():
         """
         self.description['actions'][level] = action
 
-    async def promise(self, awaitable):
+    async def promise(self, awaitable: Awaitable) -> Promise:
         """
         Promise to calculate asynchronous function and return the result in future.
 
@@ -694,8 +510,184 @@ class Scan():
             Promise: A promise object.
         """
         async with self._sem:
-            return Promise(asyncio.create_task(self._await(awaitable)))
+            task = asyncio.create_task(self._await(awaitable))
+            self._task_queue.put_nowait(task)
+            return Promise(task)
 
-    async def _await(self, awaitable):
+    async def _await(self, awaitable: Awaitable):
         async with self._sem:
             return await awaitable
+
+
+def assymbly(description):
+    mapping = {
+        label: level
+        for level, label in enumerate(
+            sorted(
+                set(description['loops'].keys())
+                | {k
+                   for k in description['actions'].keys() if k >= 0}))
+    }
+
+    if -1 in description['actions']:
+        mapping[-1] = max(mapping.values()) + 1
+
+    levels = sorted(mapping.values())
+    for k in description['actions'].keys():
+        if k < -1:
+            mapping[k] = levels[k]
+
+    description['loops'] = dict(
+        sorted([(mapping[k], v) for k, v in description['loops'].items()]))
+    description['actions'] = {
+        mapping[k]: v
+        for k, v in description['actions'].items()
+    }
+
+    for level, loops in description['loops'].items():
+        description['total'][level] = np.inf
+        for name, space in loops:
+            try:
+                description['total'][level] = min(description['total'][level],
+                                                  len(space))
+            except:
+                pass
+
+    dependents = description['dependents'].copy()
+
+    for level in levels:
+        range_list = description['loops'].get(level, [])
+        if level > 0:
+            if f'#__loop_{level}' not in description['dependents']:
+                dependents[f'#__loop_{level}'] = []
+            dependents[f'#__loop_{level}'].append(f'#__loop_{level-1}')
+        for name, _ in range_list:
+            if name not in description['dependents']:
+                dependents[name] = []
+            dependents[name].append(f'#__loop_{level}')
+
+    def _get_all_depends(key, graph):
+        ret = set()
+        if key not in graph:
+            return ret
+
+        for e in graph[key]:
+            ret.update(_get_all_depends(e, graph))
+        ret.update(graph[key])
+        return ret
+
+    full_depends = {}
+    for key in dependents:
+        full_depends[key] = _get_all_depends(key, dependents)
+
+    levels = {}
+    passed = set()
+    all_keys = set()
+    for level in reversed(description['loops'].keys()):
+        tag = f'#__loop_{level}'
+        for key, deps in full_depends.items():
+            all_keys.update(deps)
+            all_keys.add(key)
+            if key.startswith('#__loop_'):
+                continue
+            if tag in deps:
+                if level not in levels:
+                    levels[level] = set()
+                if key not in passed:
+                    passed.add(key)
+                    levels[level].add(key)
+    levels[-1] = {
+        key
+        for key in all_keys - passed if not key.startswith('#__loop_')
+    }
+
+    order = []
+    ts = TopologicalSorter(dependents)
+    ts.prepare()
+    while ts.is_active():
+        ready = ts.get_ready()
+        order.append(ready)
+        for k in ready:
+            ts.done(k)
+
+    description['order'] = {}
+
+    for level in sorted(levels):
+        keys = set(levels[level])
+        description['order'][level] = []
+        for ready in order:
+            ready = list(keys & set(ready))
+            if ready:
+                description['order'][level].append(ready)
+                keys -= set(ready)
+    return description
+
+
+async def _iter_level(variables,
+                      iters: list[tuple[str, Iterable | Expression | Callable
+                                        | OptimizeSpace]],
+                      order: list[list[str]],
+                      functions: dict[str, Callable | Expression],
+                      optimizers: dict[str, Optimizer]):
+    iters_d = {}
+    env = Env()
+    env.variables = variables
+    opts = {}
+
+    for name, iter in iters:
+        if isinstance(iter, OptimizeSpace):
+            if iter.optimizer.name not in opts:
+                opts[iter.optimizer.name] = iter.optimizer.create()
+        elif isinstance(iter, Expression):
+            iters_d[name] = iter.eval(env)
+        elif callable(iter):
+            iters_d[name] = await call_function(iter, variables)
+        else:
+            iters_d[name] = iter
+
+    maxiter = 0xffffffff
+    for name, opt in opts.items():
+        opt_cfg = optimizers[name]
+        maxiter = min(maxiter, opt_cfg.maxiter)
+
+    async for args in async_zip(*iters_d.values(), range(maxiter)):
+        variables.update(dict(zip(iters_d.keys(), args[:-1])))
+        for name, opt in opts.items():
+            args = opt.ask()
+            opt_cfg = optimizers[name]
+            variables.update({
+                n: v
+                for n, v in zip(opt_cfg.dimensions.keys(), args)
+            })
+
+        for group in order:
+            for name in group:
+                if name in functions:
+                    variables[name] = await call_function(
+                        functions[name], variables)
+
+        yield variables
+
+        for name, opt in opts.items():
+            opt_cfg = optimizers[name]
+            args = [variables[n] for n in opt_cfg.dimensions.keys()]
+            if name not in variables:
+                raise ValueError(f'{name} not in variables.')
+            fun = variables[name]
+            if inspect.isawaitable(fun):
+                fun = await fun
+            if opt_cfg.minimize:
+                opt.tell(args, fun)
+            else:
+                opt.tell(args, -fun)
+
+    for name, opt in opts.items():
+        opt_cfg = optimizers[name]
+        result = opt.get_result()
+        variables.update({
+            n: v
+            for n, v in zip(opt_cfg.dimensions.keys(), result.x)
+        })
+        variables[name] = result.fun
+    if opts:
+        yield variables

qulab/scan/utils.py

@@ -1,37 +1,83 @@
+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):]
-    }
+from typing import Any, Callable
+
+from .expression import Env, Expression
+
+
+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:
-        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)
+        sig = inspect.signature(func)
     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 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

qulab/version.py

@@ -1 +1 @@
-__version__ = "2.0.2"
+__version__ = "2.0.3"