QuLab 2.0.2__cp312-cp312-win_amd64.whl → 2.0.4__cp312-cp312-win_amd64.whl

qulab/scan/scan.py

@@ -1,13 +1,16 @@
-import ast
 import asyncio
+import datetime
 import inspect
 import itertools
+import os
+import re
 import sys
 import uuid
+import warnings
 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
@@ -19,73 +22,15 @@ from tqdm.notebook import tqdm
 from ..sys.rpc.zmq_socket import ZMQContextManager
 from .expression import Env, Expression, Symbol
 from .optimize import NgOptimizer
-from .recorder import Record
-
-
-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)
+from .recorder import Record, default_record_port
+from .utils import async_zip, call_function
 
-    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
+__process_uuid = uuid.uuid1()
+__task_counter = itertools.count()
 
 
-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 +53,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 +158,24 @@ 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 = f'tcp://127.0.0.1:{default_record_port}',
+                 mixin=None):
+        self.id = task_uuid()
         self.record = None
         self.namespace = {}
         self.description = {
@@ -238,35 +185,60 @@ class Scan():
             'consts': {},
             'functions': {},
             'optimizers': {},
+            'namespace': {},
             'actions': {},
             'dependents': {},
             'order': {},
             'filters': {},
             'total': {},
-            'compiled': False,
+            'database': database,
+            'hiden': ['self', r'^__.*', r'.*__$'],
+            'entry': {
+                'env': {},
+                'shell': '',
+                'cmds': []
+            },
         }
         self._current_level = 0
-        self.variables = {}
-        self._task = None
-        self.sock = None
-        self.database = database
         self._variables = {}
+        self._main_task = None
+        self._sock = None
         self._sem = asyncio.Semaphore(100)
-        self._bar = {}
+        self._bar: dict[int, tqdm] = {}
+        self._hide_pattern_re = re.compile('|'.join(self.description['hiden']))
+        self._task_queue = asyncio.Queue()
+        self._task_pool = []
+
+    def __del__(self):
+        try:
+            self._main_task.cancel()
+        except:
+            pass
+        for task in self._task_pool:
+            try:
+                task.cancel()
+            except:
+                pass
 
     def __getstate__(self) -> dict:
         state = self.__dict__.copy()
         del state['record']
-        del state['sock']
-        del state['_task']
+        del state['_sock']
+        del state['_main_task']
+        del state['_bar']
+        del state['_task_queue']
+        del state['_task_pool']
         del state['_sem']
         return state
 
     def __setstate__(self, state: dict) -> None:
         self.__dict__.update(state)
         self.record = None
-        self.sock = None
-        self._task = None
+        self._sock = None
+        self._main_task = None
+        self._bar = {}
+        self._task_queue = asyncio.Queue()
+        self._task_pool = []
         self._sem = asyncio.Semaphore(100)
         for opt in self.description['optimizers'].values():
             opt.scanner = self
@@ -275,23 +247,40 @@ class Scan():
     def current_level(self):
         return self._current_level
 
+    @property
+    def variables(self) -> dict[str, Any]:
+        return self._variables
+
     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({
+        if self._sock is not None:
+            await self._sock.send_pyobj({
                 'task': self.id,
                 'method': 'record_append',
                 'record_id': self.record.id,
                 '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)
+            self.record.append(current_level, step, position, {
+                k: v
+                for k, v in variables.items() if not self.hiden(k)
+            })
+
+    def hide(self, name: str):
+        self.description['hiden'].append(name)
+        self._hide_pattern_re = re.compile('|'.join(self.description['hiden']))
+
+    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:
@@ -304,37 +293,20 @@ class Scan():
             return True
 
     async def create_record(self):
-        import __main__
-        from IPython import get_ipython
-
-        ipy = get_ipython()
-        if ipy is not None:
-            scripts = ('ipython', ipy.user_ns['In'])
-        else:
-            try:
-                scripts = ('shell',
-                           [sys.executable, __main__.__file__, *sys.argv[1:]])
-            except:
-                scripts = ('', [])
-
-        if self.sock is not None:
-            await self.sock.send_pyobj({
+        if self._sock is not None:
+            await self._sock.send_pyobj({
                 'task':
                 self.id,
                 '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()
-            return Record(record_id, self.database, self.description)
-        return Record(None, self.database, self.description)
+            record_id = await self._sock.recv_pyobj()
+            return Record(record_id, self.description['database'],
+                          self.description)
+        return Record(None, self.description['database'], self.description)
 
     def get(self, name: str):
         if name in self.description['consts']:
@@ -356,7 +328,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.
 
@@ -369,6 +341,10 @@ class Scan():
         self.description['filters'][level].append(func)
 
     def set(self, name: str, value):
+        try:
+            dill.dumps(value)
+        except:
+            raise ValueError('value is not serializable.')
         if isinstance(value, Expression):
             self.add_depends(name, value.symbols())
             self.description['functions'][name] = value
@@ -427,9 +403,20 @@ 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()
-        self.variables = self.description['consts'].copy()
+        assymbly(self.description)
+        task = asyncio.create_task(self._update_progress())
+        self._task_pool.append(task)
+        self._variables = {'self': self}
+        self._variables.update(self.description['consts'])
         for level, total in self.description['total'].items():
             if total == np.inf:
                 total = None
@@ -439,11 +426,13 @@ class Scan():
                 if name in self.description['functions']:
                     self.variables[name] = await call_function(
                         self.description['functions'][name], self.variables)
-        if isinstance(self.database,
-                      str) and self.database.startswith("tcp://"):
-            async with ZMQContextManager(zmq.DEALER,
-                                         connect=self.database) as socket:
-                self.sock = socket
+        if isinstance(
+                self.description['database'],
+                str) and self.description['database'].startswith("tcp://"):
+            async with ZMQContextManager(
+                    zmq.DEALER,
+                    connect=self.description['database']) as socket:
+                self._sock = socket
                 self.record = await self.create_record()
                 await self.work()
         else:
@@ -451,214 +440,87 @@ class Scan():
             await self.work()
         for level, bar in self._bar.items():
             bar.close()
+
+        while not self._task_queue.empty():
+            evt = self._task_queue.get_nowait()
+            if isinstance(evt, asyncio.Event):
+                evt.set()
+            elif inspect.isawaitable(evt):
+                await evt
+        task.cancel()
         return self.variables
 
     async def done(self):
-        if self._task is not None:
+        if self._main_task is not None:
             try:
-                await self._task
+                await self._main_task
             except asyncio.CancelledError:
                 pass
 
+    def finished(self):
+        return self._main_task.done()
+
     def start(self):
         import asyncio
-        self._task = asyncio.create_task(self._run())
+        self._main_task = asyncio.create_task(self._run())
+
+    async def submit(self, server='tcp://127.0.0.1:6788'):
+        assymbly(self.description)
+        async with ZMQContextManager(zmq.DEALER, connect=server) as socket:
+            await socket.send_pyobj({
+                'method': 'submit',
+                'description': dill.dumps(self.description)
+            })
+            self.id = await socket.recv_pyobj()
+            await socket.send_pyobj({'method': 'get_record_id', 'id': self.id})
+            record_id = await socket.recv_pyobj()
+            self.record = Record(record_id, self.description['database'],
+                                 self.description)
 
     def cancel(self):
-        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}))
-        }
-
-        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
+        if self._main_task is not None:
+            self._main_task.cancel()
 
-        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_')
-        }
+    async def _reset_progress_bar(self, level):
+        if level in self._bar:
+            self._bar[level].reset()
 
-        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']):
             return
         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
-                task = asyncio.create_task(
+                asyncio.create_task(
                     self.emit(self.current_level - 1, step, position,
                               variables.copy()))
                 step += 1
             position += 1
             self._current_level -= 1
-            if self.current_level in self._bar:
-                self._bar[self.current_level].update(1)
-        if task is not None:
-            await task
+            self._task_queue.put_nowait(
+                self._update_progress_bar(self.current_level, 1))
         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 +545,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 +556,249 @@ 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
+
+
+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_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 assymbly(description):
+    import __main__
+    from IPython import get_ipython
+
+    description['namespace'] = dump_globals()
+
+    ipy = get_ipython()
+    if ipy is not None:
+        description['entry']['shell'] = 'ipython'
+        description['entry']['cmds'] = ipy.user_ns['In']
+    else:
+        try:
+            description['entry']['shell'] = 'shell'
+            description['entry']['cmds'] = [
+                sys.executable, __main__.__file__, *sys.argv[1:]
+            ]
+        except:
+            pass
+
+    description['entry']['env'] = {k: v for k, v in os.environ.items()}
+
+    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