QuLab 2.2.4__cp311-cp311-macosx_10_9_universal2.whl → 2.2.6__cp311-cp311-macosx_10_9_universal2.whl

{QuLab-2.2.4.dist-info → QuLab-2.2.6.dist-info}/METADATA

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

{QuLab-2.2.4.dist-info → QuLab-2.2.6.dist-info}/RECORD

@@ -1,7 +1,7 @@
 qulab/__init__.py,sha256=P-Mx2p4TVmL91SoxoeXcj8Qm0x4xUf5Q_FLk0Yc_gIQ,138
 qulab/__main__.py,sha256=ZC1NKaoxKyy60DaCfB8vYnB1z3RXQ2j8E1sRZ4A8sXE,428
-qulab/fun.cpython-311-darwin.so,sha256=Qsir5YKvUe8Be3Xpd6-KqhvHgjZlHYWVphWeOMODxaY,159616
-qulab/version.py,sha256=q2oNXq5isDMLWwNWH0ZSaEk8JVgaJMDOwWNURaUZwW0,21
+qulab/fun.cpython-311-darwin.so,sha256=VU-AxnPqaotR3zCtI9i09cvMWyTLX6x32LzM9YIkeZg,159616
+qulab/version.py,sha256=CsrswO-ECCDHSY48Nv5lOOdRgL8EGAixBOHDf7PkRZA,21
 qulab/monitor/__init__.py,sha256=nTHelnDpxRS_fl_B38TsN0njgq8eVTEz9IAnN3NbDlM,42
 qulab/monitor/__main__.py,sha256=w3yUcqq195LzSnXTkQcuC1RSFRhy4oQ_PEBmucXguME,97
 qulab/monitor/config.py,sha256=fQ5JcsMApKc1UwANEnIvbDQZl8uYW0tle92SaYtX9lI,744
@@ -17,11 +17,11 @@ qulab/scan/curd.py,sha256=thq_qfi3qng3Zx-1uhNG64IQhGCuum_LR4MOKnS8cDI,6896
 qulab/scan/expression.py,sha256=-aTYbjFQNI1mwOcoSBztqhKfGJpu_n4a1QnWro_xnTU,15694
 qulab/scan/models.py,sha256=5Jpo25WGMWs0GtLzYLsWO61G3-FFYx5BHhBr2b6rOTE,17681
 qulab/scan/optimize.py,sha256=vErjRTCtn2MwMF5Xyhs1P4gHF2IFHv_EqxsUvH_4y7k,2287
-qulab/scan/query.py,sha256=ppCChKzaTbSLcaNxdgx4CIAsw5rqaSC3flbd2y0kkaU,11541
-qulab/scan/record.py,sha256=LDbWPcBzWAmnEAqDv7Oxrwf7a_A29rk_jd9zRqQYOgc,19586
-qulab/scan/scan.py,sha256=dRtXewI8W9Fe5ZQsMz56XU-dopfa-MleEihYS0os7Eg,34422
-qulab/scan/server.py,sha256=EszeCBAHyZDdy-fq3RHPu696Do6qzsXmdamK6nkEIsw,12215
-qulab/scan/space.py,sha256=XEWQnlRYPix65LyiT6KLOK7WG2a11FJJ_M4H_dZ6Z-E,5209
+qulab/scan/query.py,sha256=-5uHMhXSyGovK1oy_uUbGVEbRFzaMBkP78ZMNfI3jD0,11809
+qulab/scan/record.py,sha256=xgmhtL9l019HYHOHvyzK1vxqagGam51rAM7sj9ZWm5U,21103
+qulab/scan/scan.py,sha256=YPGeuBwxepwmKvz3HE0X5euHqPQGSc9NUGEPEiPRiso,34884
+qulab/scan/server.py,sha256=u6in_8-AfcCA4pGAolNR_2emlewGdc3bN6c0pDygBWY,14158
+qulab/scan/space.py,sha256=jDmFY2FcYe-Qcp16YBhAEdTKibOAsHQUnpDrpcPhvzg,5279
 qulab/scan/utils.py,sha256=Pg_tCf3SUKTiPSBqb6Enkgx4bAyQJAkDGe9uYys1xVU,3613
 qulab/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/storage/__main__.py,sha256=3emxxRry8BB0m8hUZvJ_oBqkPy7ksV7flHB_KEDXZuI,1692
@@ -70,7 +70,7 @@ qulab/sys/rpc/server.py,sha256=e3R0gwOHpLEkSp7Tb43FMSDvqSG-pjrkskdISKQRseE,713
 qulab/sys/rpc/socket.py,sha256=e3R0gwOHpLEkSp7Tb43FMSDvqSG-pjrkskdISKQRseE,713
 qulab/sys/rpc/utils.py,sha256=6YGFOkY7o09lkA_I1FIP9_1Up3k2F1KOkftvu0_8lxo,594
 qulab/sys/rpc/worker.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-qulab/sys/rpc/zmq_socket.py,sha256=dx7ROCsLGQ50rGu5b0CSRL2P2aO5fbxOG9pS0T-XXCo,8147
+qulab/sys/rpc/zmq_socket.py,sha256=2uc9MjCRUwWm6iPmi2VGnOYNf9yWFSUzEVYrx0jZvPU,8272
 qulab/visualization/__init__.py,sha256=26cuHt3QIJXUb3VaMxlJx3IQTOUVJFKlYBZr7WMP53M,6129
 qulab/visualization/__main__.py,sha256=9zKK3yZFy0leU40ou6BpRC1Fsetfc1gjjFzIZYIwP6Y,1639
 qulab/visualization/_autoplot.py,sha256=jddg40dX48Wd8G6NLFA_Kf7z1QxdrZBDS99Xx2GLMqs,14099
@@ -78,9 +78,9 @@ qulab/visualization/plot_layout.py,sha256=clNw9QjE_kVNpIIx2Ob4YhAz2fucPGMuzkoIrO
 qulab/visualization/plot_seq.py,sha256=lphYF4VhkEdc_wWr1kFBwrx2yujkyFPFaJ3pjr61awI,2693
 qulab/visualization/qdat.py,sha256=ZeevBYWkzbww4xZnsjHhw7wRorJCBzbG0iEu-XQB4EA,5735
 qulab/visualization/widgets.py,sha256=6KkiTyQ8J-ei70LbPQZAK35wjktY47w2IveOa682ftA,3180
-QuLab-2.2.4.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
-QuLab-2.2.4.dist-info/METADATA,sha256=BI6WD3-Wbq6h8F1rHNYnT_0cYgd7y_f0m-L3FddbweM,3510
-QuLab-2.2.4.dist-info/WHEEL,sha256=eupBwbXGAhwNAPJSvj5BiShZwdZO8jnQ5yHfv-9aUGw,115
-QuLab-2.2.4.dist-info/entry_points.txt,sha256=ohBzutEnQimP_BZWiuXdSliu4QAYSHHcN0PZD8c7ZCY,46
-QuLab-2.2.4.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-QuLab-2.2.4.dist-info/RECORD,,
+QuLab-2.2.6.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
+QuLab-2.2.6.dist-info/METADATA,sha256=4vOBx495seNQlHygPaIrLKr2y7C5NtMIhPzwUnnI2r8,3510
+QuLab-2.2.6.dist-info/WHEEL,sha256=eupBwbXGAhwNAPJSvj5BiShZwdZO8jnQ5yHfv-9aUGw,115
+QuLab-2.2.6.dist-info/entry_points.txt,sha256=ohBzutEnQimP_BZWiuXdSliu4QAYSHHcN0PZD8c7ZCY,46
+QuLab-2.2.6.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+QuLab-2.2.6.dist-info/RECORD,,

qulab/scan/query.py

@@ -16,9 +16,13 @@ from .scan import default_server
 from .server import get_local_record
 
 
-def get_record(id, database=default_server) -> Record:
+def get_record(id,
+               database=default_server,
+               socket=None,
+               session=None) -> Record:
     if isinstance(database, str) and database.startswith('tcp://'):
-        with ZMQContextManager(zmq.DEALER, connect=database) as socket:
+        with ZMQContextManager(zmq.DEALER, connect=database,
+                               socket=socket) as socket:
             socket.send_pyobj({
                 'method': 'record_description',
                 'record_id': id
@@ -29,12 +33,16 @@ def get_record(id, database=default_server) -> Record:
             d.id = id
             d.database = database
             d._file = None
+            d._sock = socket
             return d
     else:
-        db_file = Path(database) / 'data.db'
-        engine = create_engine(f'sqlite:///{db_file}')
-        Session = sessionmaker(bind=engine)
-        with Session() as session:
+        if session is None:
+            db_file = Path(database) / 'data.db'
+            engine = create_engine(f'sqlite:///{db_file}')
+            Session = sessionmaker(bind=engine)
+            with Session() as session:
+                return get_local_record(session, id, database)
+        else:
             return get_local_record(session, id, database)
 
 

qulab/scan/record.py

@@ -56,6 +56,7 @@ class BufferList():
         self._slice = slice
         self._lock = Lock()
         self._data_id = None
+        self._sock = None
 
     def __repr__(self):
         return f"<BufferList: shape={self.shape}, lu={self.lu}, rd={self.rd}, slice={self._slice}>"
@@ -82,6 +83,7 @@ class BufferList():
         self._slice = None
         self._lock = Lock()
         self._data_id = None
+        self._sock = None
 
     @property
     def shape(self):
@@ -115,7 +117,8 @@ class BufferList():
                 self.inner_shape = value.shape
             elif self.inner_shape != value.shape:
                 self.inner_shape = ()
-        self._list.append((pos, value))
+        with self._lock:
+            self._list.append((pos, value))
         if len(self._list) > 1000:
             self.flush()
 
@@ -155,15 +158,32 @@ class BufferList():
                         yield pos, value
         else:
             server, record_id, key = self._data_id
-            with ZMQContextManager(zmq.DEALER, connect=server) as socket:
-                socket.send_pyobj({
-                    'method': 'bufferlist_slice',
-                    'record_id': record_id,
-                    'key': key,
-                    'slice': self._slice
-                })
-                ret = socket.recv_pyobj()
-                yield from ret
+            with ZMQContextManager(zmq.DEALER,
+                                   connect=server,
+                                   socket=self._sock) as socket:
+                iter_id = b''
+                start = 0
+                try:
+                    while True:
+                        socket.send_pyobj({
+                            'method': 'bufferlist_iter',
+                            'record_id': record_id,
+                            'iter_id': iter_id,
+                            'key': key,
+                            'slice': self._slice,
+                            'start': start
+                        })
+                        iter_id, lst, finished = socket.recv_pyobj()
+                        start += len(lst)
+                        yield from lst
+                        if finished:
+                            break
+                finally:
+                    if iter_id:
+                        socket.send_pyobj({
+                            'method': 'bufferlist_iter_exit',
+                            'iter_id': iter_id
+                        })
 
     def value(self):
         d = []
@@ -184,7 +204,7 @@ class BufferList():
             d.append(value)
         return p, d
 
-    def array(self):
+    def toarray(self):
         pos, data = self.items()
         if self._slice:
             pos = np.asarray(pos)
@@ -278,7 +298,7 @@ class BufferList():
     def __getitem__(self, slice_tuple: slice | EllipsisType
                     | tuple[slice | int | EllipsisType, ...]):
         self._slice, contract, reversed = self._full_slice(slice_tuple)
-        ret = self.array()
+        ret = self.toarray()
         slices = []
         for i, s in enumerate(self._slice):
             if i in contract:
@@ -303,6 +323,15 @@ class Record():
         self._pos = []
         self._last_vars = set()
         self._file = None
+        self._sock = None
+
+        for name, value in self.description['intrinsic_loops'].items():
+            self._items[name] = value
+
+        for level, range_list in description['loops'].items():
+            for name, iterable in range_list:
+                if name in self.description['independent_variables']:
+                    self._items[name] = iterable
 
         if self.is_local_record():
             self.database = Path(self.database)
@@ -324,6 +353,7 @@ class Record():
         self._last_vars = set()
         self.database = None
         self._file = None
+        self._sock = None
 
     @property
     def axis(self):
@@ -337,7 +367,8 @@ class Record():
             return cls(config_id)
         if self.is_remote_record():
             with ZMQContextManager(zmq.DEALER,
-                                   connect=self.database) as socket:
+                                   connect=self.database,
+                                   socket=self._sock) as socket:
                 socket.send_pyobj({
                     'method': 'config_get',
                     'config_id': config_id
@@ -351,6 +382,31 @@ class Record():
             session.commit()
             return cls(config)
 
+    def scripts(self, session=None):
+        scripts = self.description['entry']['scripts']
+        if isinstance(scripts, list):
+            return scripts
+        else:
+            cell_id = scripts
+
+        if self.is_remote_record():
+            with ZMQContextManager(zmq.DEALER,
+                                   connect=self.database,
+                                   socket=self._sock) as socket:
+                socket.send_pyobj({
+                    'method': 'notebook_history',
+                    'cell_id': cell_id
+                })
+                return socket.recv_pyobj()
+        elif self.is_local_record():
+            from .models import Cell
+            assert session is not None, "session is required for local record"
+            cell = session.get(Cell, cell_id)
+            return [
+                cell.input.text
+                for cell in cell.notebook.cells[1:cell.index + 2]
+            ]
+
     def is_local_record(self):
         return not self.is_cache_record() and not self.is_remote_record()
 
@@ -365,15 +421,13 @@ class Record():
         self.flush()
 
     def __getitem__(self, key):
-        ret = self.get(key, buffer_to_array=True)
-        if isinstance(ret, Space):
-            ret = ret.toarray()
-        return ret
+        return self.get(key, buffer_to_array=True)
 
-    def get(self, key, default=_not_given, buffer_to_array=False, slice=None):
+    def get(self, key, default=_not_given, buffer_to_array=False):
         if self.is_remote_record():
             with ZMQContextManager(zmq.DEALER,
-                                   connect=self.database) as socket:
+                                   connect=self.database,
+                                   socket=self._sock) as socket:
                 socket.send_pyobj({
                     'method': 'record_getitem',
                     'record_id': self.id,
@@ -381,20 +435,14 @@ class Record():
                 })
                 ret = socket.recv_pyobj()
                 if isinstance(ret, BufferList):
+                    ret._data_id = self.database, self.id, key
+                    ret._sock = socket
                     if buffer_to_array:
-                        socket.send_pyobj({
-                            'method': 'bufferlist_slice',
-                            'record_id': self.id,
-                            'key': key,
-                            'slice': slice
-                        })
-                        lst = socket.recv_pyobj()
-                        ret._list = lst
-                        ret._slice = slice
-                        return ret.array()
+                        return ret.toarray()
                     else:
-                        ret._data_id = self.database, self.id, key
                         return ret
+                elif isinstance(ret, Space) and buffer_to_array:
+                    return ret.toarray()
                 else:
                     return ret
         else:
@@ -407,7 +455,12 @@ class Record():
                     d.file = self._file.parent.parent.parent.parent / d.file
                 d._slice = slice
                 if buffer_to_array:
-                    return d.array()
+                    return d.toarray()
+                else:
+                    return d
+            elif isinstance(d, Space):
+                if buffer_to_array:
+                    return d.toarray()
                 else:
                     return d
             else:
@@ -416,7 +469,8 @@ class Record():
     def keys(self):
         if self.is_remote_record():
             with ZMQContextManager(zmq.DEALER,
-                                   connect=self.database) as socket:
+                                   connect=self.database,
+                                   socket=self._sock) as socket:
                 socket.send_pyobj({
                     'method': 'record_keys',
                     'record_id': self.id
@@ -483,7 +537,8 @@ class Record():
     def delete(self):
         if self.is_remote_record():
             with ZMQContextManager(zmq.DEALER,
-                                   connect=self.database) as socket:
+                                   connect=self.database,
+                                   socket=self._sock) as socket:
                 socket.send_pyobj({
                     'method': 'record_delete',
                     'record_id': self.id
@@ -516,36 +571,17 @@ class Record():
             with z.open('record.pkl', 'w') as f:
                 self.description['entry']['scripts'] = self.scripts()
                 dill.dump((self.description, items), f)
-
-    def scripts(self, session=None):
-        scripts = self.description['entry']['scripts']
-        if isinstance(scripts, list):
-            return scripts
-        else:
-            cell_id = scripts
-
-        if self.is_remote_record():
-            with ZMQContextManager(zmq.DEALER,
-                                   connect=self.database) as socket:
-                socket.send_pyobj({
-                    'method': 'notebook_history',
-                    'cell_id': cell_id
-                })
-                return socket.recv_pyobj()
-        elif self.is_local_record():
-            from .models import Cell
-            assert session is not None, "session is required for local record"
-            cell = session.get(Cell, cell_id)
-            return [
-                cell.input.text
-                for cell in cell.notebook.cells[1:cell.index + 2]
-            ]
+            with z.open('config.pkl', 'w') as f:
+                f.write(dill.dumps(self.config()))
 
     @classmethod
     def load(cls, file: str):
         with zipfile.ZipFile(file, 'r') as z:
             with z.open('record.pkl', 'r') as f:
                 description, items = dill.load(f)
+            with z.open('config.pkl', 'r') as f:
+                config = dill.load(f)
+            description['config'] = config
             record = cls(None, None, description)
             for key, value in items.items():
                 if isinstance(value, BufferList):

qulab/scan/scan.py

@@ -225,6 +225,7 @@ class Scan():
                  dump_globals: bool = False,
                  max_workers: int = 4,
                  max_promise: int = 100,
+                 max_message: int = 1000,
                  mixin=None):
         self.id = task_uuid()
         self.record = None
@@ -265,11 +266,12 @@ class Scan():
         self._sem = asyncio.Semaphore(max_promise + 1)
         self._bar: dict[int, tqdm] = {}
         self._hide_pattern_re = re.compile('|'.join(self.description['hiden']))
-        self._msg_queue = asyncio.Queue()
+        self._msg_queue = asyncio.Queue(max_message)
         self._prm_queue = asyncio.Queue()
         self._single_step = True
         self._max_workers = max_workers
         self._max_promise = max_promise
+        self._max_message = max_message
         self._executors = ProcessPoolExecutor(max_workers=max_workers)
 
     def __del__(self):
@@ -297,7 +299,7 @@ class Scan():
         self._main_task = None
         self._bar = {}
         self._prm_queue = asyncio.Queue()
-        self._msg_queue = asyncio.Queue()
+        self._msg_queue = asyncio.Queue(self._max_message)
         self._sem = asyncio.Semaphore(self._max_promise + 1)
         self._executors = ProcessPoolExecutor(max_workers=self._max_workers)
         for opt in self.description['optimizers'].values():
@@ -344,8 +346,9 @@ class Scan():
                 for k, v in variables.items() if not self.hiden(k)
             })
 
-    def emit(self, current_level, step, position, variables: dict[str, Any]):
-        self._msg_queue.put_nowait(
+    async def emit(self, current_level, step, position, variables: dict[str,
+                                                                        Any]):
+        await self._msg_queue.put(
             self._emit(current_level, step, position, variables.copy()))
 
     def hide(self, name: str):
@@ -552,16 +555,16 @@ class Scan():
         if isinstance(
                 self.description['database'],
                 str) and self.description['database'].startswith("tcp://"):
-            async with ZMQContextManager(
-                    zmq.DEALER,
-                    connect=self.description['database']) as socket:
+            async with ZMQContextManager(zmq.DEALER,
+                                         connect=self.description['database'],
+                                         socket=self._sock) as socket:
                 self._sock = socket
                 await self._run()
         else:
             await self._run()
 
     async def _run(self):
-        send_msg = asyncio.create_task(self._send_msg())
+        send_msg_task = asyncio.create_task(self._send_msg())
         update_progress_task = asyncio.create_task(self._update_progress())
 
         self._variables = {'self': self}
@@ -596,13 +599,13 @@ class Scan():
                 self.description['order'].get(-1, []),
                 self.description['getters'], self.variables))
 
-            self.emit(0, 0, 0, self.variables)
-            self.emit(-1, 0, 0, {})
+            await self.emit(0, 0, 0, self.variables)
+            await self.emit(-1, 0, 0, {})
 
         await self._prm_queue.join()
         update_progress_task.cancel()
         await self._msg_queue.join()
-        send_msg.cancel()
+        send_msg_task.cancel()
         return self.variables
 
     async def done(self):
@@ -621,13 +624,18 @@ class Scan():
 
     async def submit(self, server=default_executor):
         assymbly(self.description)
-        async with ZMQContextManager(zmq.DEALER, connect=server) as socket:
+        async with ZMQContextManager(zmq.DEALER,
+                                     connect=server,
+                                     socket=self._sock) as socket:
             await socket.send_pyobj({
-                'method': 'submit',
+                'method': 'task_submit',
                 'description': dill.dumps(self.description)
             })
             self.id = await socket.recv_pyobj()
-            await socket.send_pyobj({'method': 'get_record_id', 'id': self.id})
+            await socket.send_pyobj({
+                'method': 'task_get_record_id',
+                'id': self.id
+            })
             record_id = await socket.recv_pyobj()
             self.record = Record(record_id, self.description['database'],
                                  self.description)
@@ -661,14 +669,15 @@ class Scan():
             if await self._filter(variables, self.current_level - 1):
                 yield variables
                 self._single_step = False
-                self.emit(self.current_level - 1, step, position, variables)
+                await self.emit(self.current_level - 1, step, position,
+                                variables)
                 step += 1
             position += 1
             self._current_level -= 1
             self._prm_queue.put_nowait(
                 self._update_progress_bar(self.current_level, 1))
         if self.current_level == 0:
-            self.emit(self.current_level - 1, 0, 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

qulab/scan/server.py

@@ -2,6 +2,7 @@ import asyncio
 import os
 import pickle
 import time
+import uuid
 from pathlib import Path
 
 import click
@@ -29,7 +30,9 @@ else:
     datapath = Path.home() / 'qulab' / 'data'
 datapath.mkdir(parents=True, exist_ok=True)
 
+namespace = uuid.uuid4()
 record_cache = {}
+buffer_list_cache = {}
 CACHE_SIZE = 1024
 
 pool = {}
@@ -44,6 +47,9 @@ class Request():
         self.msg = pickle.loads(msg)
         self.method = self.msg.get('method', '')
 
+    def __repr__(self):
+        return f"Request({self.method})"
+
 
 async def reply(req, resp):
     await req.sock.send_multipart([req.identity, pickle.dumps(resp)])
@@ -57,6 +63,11 @@ def clear_cache():
                          range(len(record_cache) - CACHE_SIZE)):
         del record_cache[k]
 
+    for k, (t,
+            _) in zip(sorted(buffer_list_cache.items(), key=lambda x: x[1][0]),
+                      range(len(buffer_list_cache) - CACHE_SIZE)):
+        del buffer_list_cache[k]
+
 
 def flush_cache():
     for k, (t, r) in record_cache.items():
@@ -142,12 +153,37 @@ 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 'bufferlist_iter':
+            if msg['iter_id'] in buffer_list_cache:
+                it = buffer_list_cache[msg['iter_id']][1]
+                iter_id = msg['iter_id']
+            else:
+                iter_id = uuid.uuid3(namespace, str(time.time_ns())).bytes
+                record = get_record(session, msg['record_id'], datapath)
+                bufferlist = record.get(msg['key'],
+                                        buffer_to_array=False,
+                                        slice=msg['slice'])
+                it = bufferlist.iter()
+                for _, _ in zip(range(msg['start']), it):
+                    pass
+            current_time = time.time()
+            ret, end = [], False
+            while time.time() - current_time < 0.02:
+                try:
+                    ret.append(next(it))
+                except StopIteration:
+                    end = True
+                    break
+            await reply(request, (iter_id, ret, end))
+            buffer_list_cache[iter_id] = time.time(), it
+            clear_cache()
+        case 'bufferlist_iter_exit':
+            try:
+                it = buffer_list_cache.pop(msg['iter_id'])[1]
+                it.throw(Exception)
+            except:
+                pass
+            clear_cache()
         case 'record_create':
             description = dill.loads(msg['description'])
             await reply(request, record_create(session, description, datapath))
@@ -220,7 +256,7 @@ async def handle(session: Session, request: Request, datapath: Path):
                                                    'objects').parts[-4:]))
             session.commit()
             await reply(request, config.id)
-        case 'submit':
+        case 'task_submit':
             from .scan import Scan
             finished = [(id, queried) for id, (task, queried) in pool.items()
                         if not isinstance(task, int) and task.finished()]
@@ -235,7 +271,7 @@ async def handle(session: Session, request: Request, datapath: Path):
             task.start()
             pool[task.id] = [task, False]
             await reply(request, task.id)
-        case 'get_record_id':
+        case 'task_get_record_id':
             task, queried = pool.get(msg['id'])
             if isinstance(task, int):
                 await reply(request, task)
@@ -249,15 +285,28 @@ async def handle(session: Session, request: Request, datapath: Path):
                     await asyncio.sleep(1)
                 else:
                     await reply(request, None)
+        case 'task_get_progress':
+            task, _ = pool.get(msg['id'])
+            if isinstance(task, int):
+                await reply(request, 1)
+            else:
+                await reply(request,
+                            [(bar.n, bar.total) for bar in task._bar.values()])
         case _:
             logger.error(f"Unknown method: {msg['method']}")
 
 
-async def _handle(session: Session, request: Request, datapath: Path):
+async def handle_with_timeout(session: Session, request: Request,
+                              datapath: Path, timeout: float):
     try:
-        await handle(session, request, datapath)
-    except:
-        await reply(request, 'error')
+        await asyncio.wait_for(handle(session, request, datapath),
+                               timeout=timeout)
+    except asyncio.TimeoutError:
+        logger.warning(
+            f"Task handling request {request} timed out and was cancelled.")
+        await reply(request, 'timeout')
+    except Exception as e:
+        await reply(request, f'{e!r}')
 
 
 async def serv(port,
@@ -280,7 +329,8 @@ async def serv(port,
                 identity, msg = await sock.recv_multipart()
                 received += len(msg)
                 req = Request(sock, identity, msg)
-                asyncio.create_task(_handle(session, req, datapath))
+                asyncio.create_task(
+                    handle_with_timeout(session, req, datapath, timeout=60.0))
                 if received > buffer_size or time.time(
                 ) - last_flush_time > interval:
                     flush_cache()

qulab/scan/space.py

@@ -28,6 +28,8 @@ class Space():
             return space
         if isinstance(space, (list, tuple)):
             array = np.array(space)
+        elif isinstance(space, np.ndarray):
+            array = space
         try:
             a = np.linspace(array[0], array[-1], len(array), dtype=array.dtype)
             if np.allclose(a, array):

qulab/sys/rpc/zmq_socket.py

@@ -130,7 +130,12 @@ class ZMQContextManager:
         self.auth = None
         self.context = None
         self.socket = None
-        self._external_socket = socket
+        self._external_socket = None
+        try:
+            if not socket.closed:
+                self._external_socket = socket
+        except:
+            pass
 
     def _create_socket(self, asyncio=False) -> zmq.Socket:
         """

qulab/version.py

@@ -1 +1 @@
-__version__ = "2.2.4"
+__version__ = "2.2.6"