QuLab 2.0.5__cp311-cp311-win_amd64.whl → 2.0.7__cp311-cp311-win_amd64.whl

{QuLab-2.0.5.dist-info → QuLab-2.0.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: QuLab
-Version: 2.0.5
+Version: 2.0.7
 Summary: contral instruments and manage data
 Author-email: feihoo87 <feihoo87@gmail.com>
 Maintainer-email: feihoo87 <feihoo87@gmail.com>

{QuLab-2.0.5.dist-info → QuLab-2.0.7.dist-info}/RECORD

@@ -1,7 +1,7 @@
 qulab/__init__.py,sha256=8zLGg-DfQhnDl2Ky0n-zXpN-8e-g7iR0AcaI4l4Vvpk,32
 qulab/__main__.py,sha256=XN2wrhlmEkTIPq_ZeSaO8rWXfYgD2Czkm9DVFVoCw_U,515
-qulab/fun.cp311-win_amd64.pyd,sha256=ay6Srz8qiZP0Hsxatsz1d-2YK0FTjJ0Nsyp9TEiduMA,31232
-qulab/version.py,sha256=W2bKmLHMwuaZj0IuSoqothHJumPaUDyIwYJTzE6Hdd0,21
+qulab/fun.cp311-win_amd64.pyd,sha256=jCMRaQoq_yQDw7haxtPNmjGu5nRk1LTJzAZfTd1BJ6I,31232
+qulab/version.py,sha256=Ch1foRTConPN5Ppjf6BSKYuXYy0kR0uQuUlG41WPUX4,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
@@ -18,8 +18,8 @@ qulab/scan/expression.py,sha256=vwUM9E0OFQal4bljlUtLR3NJu4zGRyuWYrdyZSs3QTU,1619
 qulab/scan/models.py,sha256=TkiVHF_fUZzYHs4MsCTRh391thpf4Ozd3R_LAU0Gxkg,17657
 qulab/scan/optimize.py,sha256=MlT4y422CnP961IR384UKryyZh8riNvrPSd2z_MXLEg,2356
 qulab/scan/query_record.py,sha256=rpw4U3NjLzlv9QMwKdCvEUGHjzPF8u1UpodfLW8aoTY,11853
-qulab/scan/recorder.py,sha256=wv8o_teAYYM_RaRQHkfa4-cF-ak68tzcb_QH9jlTH7A,18456
-qulab/scan/scan.py,sha256=nvvkGWmKWueeJ1pRAax3yKZn-vqlMvt10_oPSWd2hJw,26742
+qulab/scan/recorder.py,sha256=lbIASqH4-4eTzqX1sG9K1LnUkqvkcRK5ab2OpXSeE-Y,22801
+qulab/scan/scan.py,sha256=QIMjc9JpB-4Epsg8WPgEmHKppJ1dWTY2R8H5Co6YRG0,28937
 qulab/scan/server.py,sha256=zDZfG6bOB3EUubfByQMq0BSQ9C6IV_Av0tDinzgpGjQ,2950
 qulab/scan/utils.py,sha256=XM-eKL5Xkm0hihhGS7Kq4g654Ye7n7TcU_f95gxtXq8,2634
 qulab/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -77,9 +77,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.5.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
-QuLab-2.0.5.dist-info/METADATA,sha256=siWaIXTJ0sU7pu5cBNaFGe2ecL8-tlbywjkxHYzGF-0,3609
-QuLab-2.0.5.dist-info/WHEEL,sha256=nSybvzWlmdJnHiUQSY-d7V1ycwEVUTqXiTvr2eshg44,102
-QuLab-2.0.5.dist-info/entry_points.txt,sha256=ohBzutEnQimP_BZWiuXdSliu4QAYSHHcN0PZD8c7ZCY,46
-QuLab-2.0.5.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-QuLab-2.0.5.dist-info/RECORD,,
+QuLab-2.0.7.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
+QuLab-2.0.7.dist-info/METADATA,sha256=4YsQ1mzdMruQZL4uFSVCEQ0UX71Jd3iz3tPAInCKOLU,3609
+QuLab-2.0.7.dist-info/WHEEL,sha256=nSybvzWlmdJnHiUQSY-d7V1ycwEVUTqXiTvr2eshg44,102
+QuLab-2.0.7.dist-info/entry_points.txt,sha256=ohBzutEnQimP_BZWiuXdSliu4QAYSHHcN0PZD8c7ZCY,46
+QuLab-2.0.7.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+QuLab-2.0.7.dist-info/RECORD,,

qulab/scan/recorder.py

@@ -1,4 +1,5 @@
 import asyncio
+import itertools
 import os
 import pickle
 import sys
@@ -7,6 +8,7 @@ import uuid
 from collections import defaultdict
 from pathlib import Path
 from threading import Lock
+from types import EllipsisType
 
 import click
 import dill
@@ -44,52 +46,74 @@ def random_path(base):
             return path
 
 
+def index_in_slice(slice_obj: slice | int, index: int):
+    if isinstance(slice_obj, int):
+        return slice_obj == index
+    start, stop, step = slice_obj.start, slice_obj.stop, slice_obj.step
+    if start is None:
+        start = 0
+    if step is None:
+        step = 1
+    if stop is None:
+        stop = sys.maxsize
+
+    if step > 0:
+        return start <= index < stop and (index - start) % step == 0
+    else:
+        return stop < index <= start and (index - start) % step == 0
+
+
 class BufferList():
 
-    def __init__(self, pos_file=None, value_file=None):
-        self._pos = []
-        self._value = []
+    def __init__(self, file=None, slice=None):
+        self._list = []
         self.lu = ()
         self.rd = ()
-        self.pos_file = pos_file
-        self.value_file = value_file
+        self.inner_shape = None
+        self.file = file
+        self._slice = slice
         self._lock = Lock()
+        self._database = None
+
+    def __repr__(self):
+        return f"<BufferList: lu={self.lu}, rd={self.rd}, slice={self._slice}>"
 
     def __getstate__(self):
+        self.flush()
+        if isinstance(self.file, Path):
+            file = '/'.join(self.file.parts[-4:])
+        else:
+            file = self.file
         return {
-            'pos_file': self.pos_file,
-            'value_file': self.value_file,
-            '_pos': self._pos,
-            '_value': self._value,
+            'file': file,
             'lu': self.lu,
-            'rd': self.rd
+            'rd': self.rd,
+            'inner_shape': self.inner_shape,
         }
 
     def __setstate__(self, state):
-        self.pos_file = state['pos_file']
-        self.value_file = state['value_file']
-        self._pos = state['_pos']
-        self._value = state['_value']
+        self.file = state['file']
         self.lu = state['lu']
         self.rd = state['rd']
+        self.inner_shape = state['inner_shape']
+        self._list = []
+        self._slice = None
         self._lock = Lock()
+        self._database = None
 
     @property
     def shape(self):
         return tuple([i - j for i, j in zip(self.rd, self.lu)])
 
     def flush(self):
-        with self._lock:
-            if self.pos_file is not None:
-                with open(self.pos_file, 'ab') as f:
-                    for pos in self._pos:
-                        dill.dump(pos, f)
-                self._pos.clear()
-            if self.value_file is not None:
-                with open(self.value_file, 'ab') as f:
-                    for value in self._value:
-                        dill.dump(value, f)
-                self._value.clear()
+        if not self._list:
+            return
+        if isinstance(self.file, Path):
+            with self._lock:
+                with open(self.file, 'ab') as f:
+                    for item in self._list:
+                        dill.dump(item, f)
+                self._list.clear()
 
     def append(self, pos, value, dims=None):
         if dims is not None:
@@ -98,45 +122,96 @@ class BufferList():
             pos = tuple([pos[i] for i in dims])
         self.lu = tuple([min(i, j) for i, j in zip(pos, self.lu)])
         self.rd = tuple([max(i + 1, j) for i, j in zip(pos, self.rd)])
-        self._pos.append(pos)
-        self._value.append(value)
-        if len(self._value) > 1000:
+        if hasattr(value, 'shape'):
+            if self.inner_shape is None:
+                self.inner_shape = value.shape
+            elif self.inner_shape != value.shape:
+                self.inner_shape = ()
+        self._list.append((pos, value))
+        if len(self._list) > 1000:
             self.flush()
 
-    def value(self):
-        v = []
-        if self.value_file is not None and self.value_file.exists():
+    def _iter_file(self):
+        if isinstance(self.file, Path) and self.file.exists():
             with self._lock:
-                with open(self.value_file, 'rb') as f:
+                with open(self.file, 'rb') as f:
                     while True:
                         try:
-                            v.append(dill.load(f))
+                            pos, value = dill.load(f)
+                            yield pos, value
                         except EOFError:
                             break
-        v.extend(self._value)
-        return v
+
+    def iter(self):
+        for pos, value in itertools.chain(self._iter_file(), self._list):
+            if not self._slice:
+                yield pos, value
+            elif all([index_in_slice(s, i) for s, i in zip(self._slice, pos)]):
+                yield pos, value[self._slice[len(pos):]]
+
+    def value(self):
+        d = []
+        for pos, value in self.iter():
+            d.append(value)
+        return d
 
     def pos(self):
         p = []
-        if self.pos_file is not None and self.pos_file.exists():
-            with self._lock:
-                with open(self.pos_file, 'rb') as f:
-                    while True:
-                        try:
-                            p.append(dill.load(f))
-                        except EOFError:
-                            break
-        p.extend(self._pos)
+        for pos, value in self.iter():
+            p.append(pos)
         return p
 
+    def items(self):
+        p, d = [], []
+        for pos, value in self.iter():
+            p.append(pos)
+            d.append(value)
+        return p, d
+
     def array(self):
-        pos = np.asarray(self.pos()) - np.asarray(self.lu)
-        data = np.asarray(self.value())
+        pos, data = self.items()
+        pos = np.asarray(pos) - np.asarray(self.lu)
+        data = np.asarray(data)
         inner_shape = data.shape[1:]
         x = np.full(self.shape + inner_shape, np.nan, dtype=data[0].dtype)
         x.__setitem__(tuple(pos.T), data)
         return x
 
+    def _full_slice(self, slice_tuple: slice
+                    | tuple[slice | int | EllipsisType, ...]):
+        if isinstance(slice_tuple, slice):
+            slice_tuple = (slice_tuple, ) + (slice(0, sys.maxsize,
+                                                   1), ) * (len(self.lu) - 1)
+        if slice_tuple is Ellipsis:
+            slice_tuple = (slice(0, sys.maxsize, 1), ) * len(self.lu)
+        else:
+            head, tail = [], []
+            for i, s in enumerate(slice_tuple):
+                if s is Ellipsis:
+                    head = slice_tuple[:i]
+                    tail = slice_tuple[i + 1:]
+                    break
+            slice_tuple = head + (slice(0, sys.maxsize, 1), ) * (
+                len(self.lu) - len(head) - len(tail)) + tail
+        slice_list = []
+        for s in slice_tuple:
+            if isinstance(s, int):
+                slice_list.append(s)
+            else:
+                start, stop, step = s.start, s.stop, s.step
+                if start is None:
+                    start = 0
+                if step is None:
+                    step = 1
+                if stop is None:
+                    stop = sys.maxsize
+                slice_list.append(slice(start, stop, step))
+        return tuple(slice_list)
+
+    def __getitem__(self, slice_tuple: slice | EllipsisType
+                    | tuple[slice | int | EllipsisType, ...]):
+        return super().__getitem__(self._full_slice(slice_tuple))
+
 
 class Record():
 
@@ -149,7 +224,6 @@ class Record():
         self._index = []
         self._pos = []
         self._last_vars = set()
-        self._levels = {}
         self._file = None
         self.independent_variables = {}
         self.constants = {}
@@ -170,7 +244,6 @@ class Record():
         for level, group in self.description['order'].items():
             for names in group:
                 for name in names:
-                    self._levels[name] = level
                     if name not in self.dims:
                         if name not in self.description['dependents']:
                             self.dims[name] = (level, )
@@ -185,6 +258,35 @@ class Record():
             self._file = random_path(self.database / 'objects')
             self._file.parent.mkdir(parents=True, exist_ok=True)
 
+    def __getstate__(self) -> dict:
+        return {
+            'id': self.id,
+            'database': self.database,
+            'description': self.description,
+            '_keys': self._keys,
+            '_items': self._items,
+            '_index': self._index,
+            '_pos': self._pos,
+            '_last_vars': self._last_vars,
+            'independent_variables': self.independent_variables,
+            'constants': self.constants,
+            'dims': self.dims,
+        }
+
+    def __setstate__(self, state: dict):
+        self.id = state['id']
+        self.database = state['database']
+        self.description = state['description']
+        self._keys = state['_keys']
+        self._items = state['_items']
+        self._index = state['_index']
+        self._pos = state['_pos']
+        self._last_vars = state['_last_vars']
+        self.independent_variables = state['independent_variables']
+        self.constants = state['constants']
+        self.dims = state['dims']
+        self._file = None
+
     def is_local_record(self):
         return not self.is_cache_record() and not self.is_remote_record()
 
@@ -201,7 +303,7 @@ class Record():
     def __getitem__(self, key):
         return self.get(key)
 
-    def get(self, key, default=_notgiven, buffer_to_array=True):
+    def get(self, key, default=_notgiven, buffer_to_array=True, slice=None):
         if self.is_remote_record():
             with ZMQContextManager(zmq.DEALER,
                                    connect=self.database) as socket:
@@ -211,8 +313,21 @@ class Record():
                     'key': key
                 })
                 ret = socket.recv_pyobj()
-                if isinstance(ret, BufferList) and buffer_to_array:
-                    return ret.array()
+                if isinstance(ret, BufferList):
+                    socket.send_pyobj({
+                        'method': 'bufferlist_slice',
+                        'record_id': self.id,
+                        'key': key,
+                        'slice': slice
+                    })
+                    lst = socket.recv_pyobj()
+                    ret._list = lst
+                    ret._slice = slice
+                    if buffer_to_array:
+                        return ret.array()
+                    else:
+                        ret._database = self.database
+                        return ret
                 else:
                     return ret
         else:
@@ -221,15 +336,13 @@ class Record():
             else:
                 d = self._items.get(key, default)
             if isinstance(d, BufferList):
+                if isinstance(d.file, str):
+                    d.file = self._file.parent.parent.parent.parent / d.file
+                d._slice = slice
                 if buffer_to_array:
                     return d.array()
                 else:
-                    ret = BufferList()
-                    ret._pos = d.pos()
-                    ret._value = d.value()
-                    ret.lu = d.lu
-                    ret.rd = d.rd
-                    return ret
+                    return d
             else:
                 return d
 
@@ -251,8 +364,7 @@ class Record():
             return
 
         for key in set(variables.keys()) - self._last_vars:
-            if key not in self._levels:
-                self._levels[key] = level
+            if key not in self.dims:
                 self.dims[key] = tuple(range(level + 1))
 
         self._last_vars = set(variables.keys())
@@ -276,14 +388,17 @@ class Record():
             self._pos[-1] += 1
 
         for key, value in variables.items():
-            if level == self._levels[key]:
+            if self.dims[key] == ():
+                if key not in self._items:
+                    self._items[key] = value
+            elif level == self.dims[key][-1]:
                 if key not in self._items:
                     if self.is_local_record():
-                        f1 = random_path(self.database / 'objects')
-                        f1.parent.mkdir(parents=True, exist_ok=True)
-                        f2 = random_path(self.database / 'objects')
-                        f2.parent.mkdir(parents=True, exist_ok=True)
-                        self._items[key] = BufferList(f1, f2)
+                        bufferlist_file = random_path(self.database /
+                                                      'objects')
+                        bufferlist_file.parent.mkdir(parents=True,
+                                                     exist_ok=True)
+                        self._items[key] = BufferList(bufferlist_file)
                     else:
                         self._items[key] = BufferList()
                     self._items[key].lu = pos
@@ -291,8 +406,6 @@ class Record():
                     self._items[key].append(pos, value, self.dims[key])
                 elif isinstance(self._items[key], BufferList):
                     self._items[key].append(pos, value, self.dims[key])
-            elif self._levels[key] == -1 and key not in self._items:
-                self._items[key] = value
 
     def flush(self):
         if self.is_remote_record() or self.is_cache_record():
@@ -307,7 +420,7 @@ class Record():
 
     def __repr__(self):
         return f"<Record: id={self.id} app={self.description['app']}, keys={self.keys()}>"
-    
+
     # def _repr_html_(self):
     #     return f"""
     #     <h3>Record: id={self.id}, app={self.description['app']}</h3>
@@ -351,6 +464,7 @@ def get_record(session: Session, id: int, datapath: Path) -> Record:
         path = datapath / 'objects' / record_in_db.file
         with open(path, 'rb') as f:
             record = dill.load(f)
+            record._file = path
     else:
         record = record_cache[id][1]
     clear_cache()
@@ -400,6 +514,12 @@ async def handle(session: Session, request: Request, datapath: Path):
     match request.method:
         case 'ping':
             await reply(request, 'pong')
+        case 'bufferlist_slice':
+            record = get_record(session, msg['record_id'], datapath)
+            bufferlist = record.get(msg['key'],
+                                    buffer_to_array=False,
+                                    slice=msg['slice'])
+            await reply(request, list(bufferlist.iter()))
         case 'record_create':
             description = dill.loads(msg['description'])
             await reply(request, record_create(session, description, datapath))

qulab/scan/scan.py

@@ -185,6 +185,8 @@ class Scan():
             'loops': {},
             'consts': {},
             'functions': {},
+            'getters': {},
+            'setters': {},
             'optimizers': {},
             'namespace': {} if dump_globals else None,
             'actions': {},
@@ -342,7 +344,7 @@ class Scan():
             self.description['filters'][level] = []
         self.description['filters'][level].append(func)
 
-    def set(self, name: str, value):
+    def set(self, name: str, value, setter: Callable | None = None):
         try:
             dill.dumps(value)
         except:
@@ -355,8 +357,14 @@ class Scan():
             self.description['functions'][name] = value
         else:
             self.description['consts'][name] = value
-
-    def search(self, name: str, range, level: int | None = None):
+        if setter:
+            self.description['setters'][name] = setter
+
+    def search(self,
+               name: str,
+               range: Iterable | Expression | Callable | OptimizeSpace,
+               level: int | None = None,
+               setter: Callable | None = None):
         if level is not None:
             assert level >= 0, 'level must be greater than or equal to 0.'
         if isinstance(range, OptimizeSpace):
@@ -370,12 +378,23 @@ class Scan():
             self._add_loop_var(name, level, range)
             if isinstance(range, Expression) or callable(range):
                 self.add_depends(name, range.symbols())
+        if setter:
+            self.description['setters'][name] = setter
+
+    def trace(self,
+              name: str,
+              depends: list[str],
+              getter: Callable | None = None):
+        self.add_depends(name, depends)
+        if getter:
+            self.description['getters'][name] = getter
 
     def minimize(self,
                  name: str,
                  level: int,
                  method=NgOptimizer,
                  maxiter=100,
+                 getter: Callable | None = None,
                  **kwds) -> Optimizer:
         assert level >= 0, 'level must be greater than or equal to 0.'
         opt = Optimizer(self,
@@ -386,6 +405,8 @@ class Scan():
                         minimize=True,
                         **kwds)
         self.description['optimizers'][name] = opt
+        if getter:
+            self.description['getters'][name] = getter
         return opt
 
     def maximize(self,
@@ -393,6 +414,7 @@ class Scan():
                  level: int,
                  method=NgOptimizer,
                  maxiter=100,
+                 getter: Callable | None = None,
                  **kwds) -> Optimizer:
         assert level >= 0, 'level must be greater than or equal to 0.'
         opt = Optimizer(self,
@@ -403,6 +425,8 @@ class Scan():
                         minimize=False,
                         **kwds)
         self.description['optimizers'][name] = opt
+        if getter:
+            self.description['getters'][name] = getter
         return opt
 
     async def _update_progress(self):
@@ -418,7 +442,8 @@ class Scan():
         task = asyncio.create_task(self._update_progress())
         self._task_pool.append(task)
         self._variables = {'self': self}
-        self._variables.update(self.description['consts'])
+        await _update_variables(self._variables, self.description['consts'],
+                                self.description['setters'])
         for level, total in self.description['total'].items():
             if total == np.inf:
                 total = None
@@ -428,6 +453,11 @@ class Scan():
                 if name in self.description['functions']:
                     self.variables[name] = await call_function(
                         self.description['functions'][name], self.variables)
+                if name in self.description['setters']:
+                    coro = self.description['setters'][name](
+                        self.variables[name])
+                    if inspect.isawaitable(coro):
+                        await coro
         if isinstance(
                 self.description['database'],
                 str) and self.description['database'].startswith("tcp://"):
@@ -505,7 +535,8 @@ class Scan():
                 self.variables,
                 self.description['loops'].get(self.current_level, []),
                 self.description['order'].get(self.current_level, []),
-                self.description['functions'], self.description['optimizers']):
+                self.description['functions'], self.description['optimizers'],
+                self.description['setters'], self.description['getters']):
             self._current_level += 1
             if await self._filter(variables, self.current_level - 1):
                 yield variables
@@ -561,10 +592,13 @@ class Scan():
         Returns:
             Promise: A promise object.
         """
-        async with self._sem:
-            task = asyncio.create_task(self._await(awaitable))
-            self._task_queue.put_nowait(task)
-            return Promise(task)
+        if inspect.isawaitable(awaitable):
+            async with self._sem:
+                task = asyncio.create_task(self._await(awaitable))
+                self._task_queue.put_nowait(task)
+                return Promise(task)
+        else:
+            return awaitable
 
     async def _await(self, awaitable: Awaitable):
         async with self._sem:
@@ -741,12 +775,23 @@ def assymbly(description):
     return description
 
 
+async def _update_variables(variables, updates, setters):
+    for name, value in updates.items():
+        if name in setters:
+            coro = setters[name](value)
+            if inspect.isawaitable(coro):
+                await coro
+        variables[name] = value
+
+
 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]):
+                      optimizers: dict[str, Optimizer],
+                      setters: dict[str, Callable] = {},
+                      getters: dict[str, Callable] = {}):
     iters_d = {}
     env = Env()
     env.variables = variables
@@ -769,23 +814,32 @@ async def _iter_level(variables,
         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])))
+        await _update_variables(variables, dict(zip(iters_d.keys(),
+                                                    args[:-1])), setters)
         for name, opt in opts.items():
             args = opt.ask()
             opt_cfg = optimizers[name]
-            variables.update({
+            await _update_variables(variables, {
                 n: v
                 for n, v in zip(opt_cfg.dimensions.keys(), args)
-            })
+            }, setters)
 
         for group in order:
             for name in group:
                 if name in functions:
-                    variables[name] = await call_function(
-                        functions[name], variables)
+                    await _update_variables(variables, {
+                        name:
+                        await call_function(functions[name], variables)
+                    }, setters)
 
         yield variables
 
+        for group in order:
+            for name in group:
+                if name in getters:
+                    variables[name] = await call_function(
+                        getters[name], variables)
+
         for name, opt in opts.items():
             opt_cfg = optimizers[name]
             args = [variables[n] for n in opt_cfg.dimensions.keys()]

qulab/version.py

@@ -1 +1 @@
-__version__ = "2.0.5"
+__version__ = "2.0.7"