QuLab 2.3.2__cp311-cp311-macosx_10_9_universal2.whl → 2.3.4__cp311-cp311-macosx_10_9_universal2.whl

{QuLab-2.3.2.dist-info → QuLab-2.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: QuLab
-Version: 2.3.2
+Version: 2.3.4
 Summary: contral instruments and manage data
 Author-email: feihoo87 <feihoo87@gmail.com>
 Maintainer-email: feihoo87 <feihoo87@gmail.com>
@@ -38,6 +38,9 @@ Requires-Dist: ply >=3.11
 Requires-Dist: pyzmq >=25.1.0
 Requires-Dist: scipy >=1.0.0
 Requires-Dist: watchdog >=4.0.0
+Provides-Extra: full
+Requires-Dist: SQLAlchemy >=2.0.19 ; extra == 'full'
+Requires-Dist: uvloop >=0.19.0 ; extra == 'full'
 
 # QuLab
 [![View build status](https://travis-ci.org/feihoo87/QuLab.svg?branch=master)](https://travis-ci.org/feihoo87/QuLab)

{QuLab-2.3.2.dist-info → QuLab-2.3.4.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=aFDKwsfj4iIn_qPA_HgPOb23YQ_AwnE5G_fPkQEbQIs,159616
-qulab/version.py,sha256=wmsQzkE8l2rmrt5-AjUYaTVQ_X-dbo-FDvqay4JDxVk,21
+qulab/fun.cpython-311-darwin.so,sha256=VAuzZloDPT2N99qUrQIFhgFcr9_xk3BSQ_7PXUyDVJ4,159616
+qulab/version.py,sha256=MtmOJMh3yHY9aTdRsZDgbpPfbzm9xdycdi9jjMKzYjM,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
@@ -14,15 +14,15 @@ qulab/monitor/qt_compat.py,sha256=OK71_JSO_iyXjRIKHANmaK4Lx4bILUzmXI-mwKg3QeI,78
 qulab/monitor/toolbar.py,sha256=WEag6cxAtEsOLL14XvM7pSE56EA3MO188_JuprNjdBs,7948
 qulab/scan/__init__.py,sha256=ZX4WsvqYxvJeHLgGSrtJoAnVU94gxY7EHKMxYooMERg,130
 qulab/scan/curd.py,sha256=thq_qfi3qng3Zx-1uhNG64IQhGCuum_LR4MOKnS8cDI,6896
-qulab/scan/expression.py,sha256=s2_sWFm4gKgJ7pGLmuugCU8XifAm9Mc3AT3bdoyFUtM,19459
+qulab/scan/expression.py,sha256=ngWrP1o9CuYJ1gq5YHaV7EfxKIKUX7Gz6KG80E6XThY,20070
 qulab/scan/models.py,sha256=5Jpo25WGMWs0GtLzYLsWO61G3-FFYx5BHhBr2b6rOTE,17681
 qulab/scan/optimize.py,sha256=jYceGazEabuwYqmZE8P6Nnq_KsLyUP0p-p88VbbJLhM,2559
 qulab/scan/query.py,sha256=-5uHMhXSyGovK1oy_uUbGVEbRFzaMBkP78ZMNfI3jD0,11809
-qulab/scan/record.py,sha256=sICMLAWf3IgvJ3JlS0cKQA4mSpLZins7K5qFoAnCSYI,21194
-qulab/scan/scan.py,sha256=KjQyq42xFi9wCjFTu26cXzV5_iii2X0dceqzL1s5w3Q,37834
-qulab/scan/server.py,sha256=ZT-J447xuLSpmbTNm5dNIz8_CXKOow66_bjkFNGh_vI,14274
+qulab/scan/record.py,sha256=yIHPANf6nuBXy8Igf-dMtGJ7wuFTLYlBaaAUc0AzwyU,21280
+qulab/scan/scan.py,sha256=hrCnoIROMPoYXEZnU9GTZUR-aX9qP58d40wlN3DTQCE,40602
+qulab/scan/server.py,sha256=_4YrOJcnqDTnxryZXE8lEKGzuT4LS-8q9bN6jrTEqUQ,19950
 qulab/scan/space.py,sha256=X5anTvw7X0XGN83y0o0C-zhvh6bDEU-kshGgo004pNE,6076
-qulab/scan/utils.py,sha256=Pg_tCf3SUKTiPSBqb6Enkgx4bAyQJAkDGe9uYys1xVU,3613
+qulab/scan/utils.py,sha256=zCV_Td8hBgb16Hv3XKo64KYDDpvBw2rQ83fxq1hvjG8,4586
 qulab/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/storage/__main__.py,sha256=3emxxRry8BB0m8hUZvJ_oBqkPy7ksV7flHB_KEDXZuI,1692
 qulab/storage/base_dataset.py,sha256=4aKhqBNdZfdlm_z1Qy5dv0HrvgpvMdy8pbyfua8uE-4,11865
@@ -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.3.2.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
-QuLab-2.3.2.dist-info/METADATA,sha256=mLdXTnca-RyYTycpdpxKFyrFe9UPysvw5sBDoGhqcAg,3510
-QuLab-2.3.2.dist-info/WHEEL,sha256=UDBB_KFYXAT_a6Q3uGzMOBYEG2sfuzNdKs9Nu_rq9v4,114
-QuLab-2.3.2.dist-info/entry_points.txt,sha256=ohBzutEnQimP_BZWiuXdSliu4QAYSHHcN0PZD8c7ZCY,46
-QuLab-2.3.2.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-QuLab-2.3.2.dist-info/RECORD,,
+QuLab-2.3.4.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
+QuLab-2.3.4.dist-info/METADATA,sha256=Noz4IplxqE9TBtcN2Qr38B1J0vtpEkCWsjAjvRMGF_I,3633
+QuLab-2.3.4.dist-info/WHEEL,sha256=UDBB_KFYXAT_a6Q3uGzMOBYEG2sfuzNdKs9Nu_rq9v4,114
+QuLab-2.3.4.dist-info/entry_points.txt,sha256=ohBzutEnQimP_BZWiuXdSliu4QAYSHHcN0PZD8c7ZCY,46
+QuLab-2.3.4.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+QuLab-2.3.4.dist-info/RECORD,,

qulab/scan/expression.py

@@ -419,7 +419,7 @@ class Expression():
     def is_const(self, env) -> bool:
         return False
 
-    def value(self, env):
+    def value(self, env=_default_env):
         if self.changed(env):
             self.cache = self.eval(env)
         return self.cache
@@ -612,3 +612,31 @@ class Symbol(Expression):
 
     def __repr__(self) -> str:
         return self.name
+
+
+sin = Symbol('sin')
+cos = Symbol('cos')
+tan = Symbol('tan')
+pi = Symbol('pi')
+e = Symbol('e')
+log = Symbol('log')
+log2 = Symbol('log2')
+log10 = Symbol('log10')
+exp = Symbol('exp')
+sqrt = Symbol('sqrt')
+abs = Symbol('abs')
+sinh = Symbol('sinh')
+cosh = Symbol('cosh')
+tanh = Symbol('tanh')
+arcsin = Symbol('arcsin')
+arccos = Symbol('arccos')
+arctan = Symbol('arctan')
+arctan2 = Symbol('arctan2')
+arcsinh = Symbol('arcsinh')
+arccosh = Symbol('arccosh')
+arctanh = Symbol('arctanh')
+sinc = Symbol('sinc')
+sign = Symbol('sign')
+heaviside = Symbol('heaviside')
+erf = Symbol('erf')
+erfc = Symbol('erfc')

qulab/scan/record.py

@@ -474,7 +474,9 @@ class Record():
                     'method': 'record_keys',
                     'record_id': self.id
                 })
-                return socket.recv_pyobj()
+                keys = socket.recv_pyobj()
+                self._items = {key: None for key in keys}
+                return keys
         else:
             return list(self._items.keys())
 

qulab/scan/scan.py

@@ -1,4 +1,5 @@
 import asyncio
+import contextlib
 import copy
 import inspect
 import itertools
@@ -25,7 +26,7 @@ from .optimize import NgOptimizer
 from .record import Record
 from .server import default_record_port
 from .space import Optimizer, OptimizeSpace, Space
-from .utils import async_zip, call_function, dump_globals
+from .utils import async_zip, call_function, dump_dict, dump_globals
 
 try:
     from tqdm.notebook import tqdm
@@ -263,6 +264,7 @@ class Scan():
         self._current_level = 0
         self._variables = {}
         self._main_task = None
+        self._background_tasks = ()
         self._sock = None
         self._sem = asyncio.Semaphore(max_promise + 1)
         self._bar: dict[int, tqdm] = {}
@@ -286,6 +288,7 @@ class Scan():
         del state['record']
         del state['_sock']
         del state['_main_task']
+        del state['_background_tasks']
         del state['_bar']
         del state['_msg_queue']
         del state['_prm_queue']
@@ -298,6 +301,7 @@ class Scan():
         self.record = None
         self._sock = None
         self._main_task = None
+        self._background_tasks = ()
         self._bar = {}
         self._prm_queue = asyncio.Queue()
         self._msg_queue = asyncio.Queue(self._max_message)
@@ -331,6 +335,9 @@ class Scan():
                 await _unpack(key, variables)
             elif inspect.isawaitable(value) and not self.hiden(key):
                 variables[key] = await value
+
+        if self.record is None:
+            self.record = await self.create_record()
         if self._sock is not None:
             await self._sock.send_pyobj({
                 'task': self.id,
@@ -374,20 +381,37 @@ class Scan():
             return True
 
     async def create_record(self):
-        if self._sock is not None:
-            await self._sock.send_pyobj({
-                'task':
-                self.id,
-                'method':
-                'record_create',
-                'description':
-                dill.dumps(self.description)
-            })
+        if self._sock is None:
+            return Record(None, self.description['database'], self.description)
+
+        if self.config:
+            self.description['config'] = await create_config(
+                self.config, self.description['database'], self._sock)
+        if current_notebook() is None:
+            await create_notebook('untitle', self.description['database'],
+                                  self._sock)
+        cell_id = await save_input_cells(current_notebook(),
+                                         self.description['entry']['scripts'],
+                                         self.description['database'],
+                                         self._sock)
+        self.description['entry']['scripts'] = cell_id
+
+        await self._sock.send_pyobj({
+            'task':
+            self.id,
+            'method':
+            'record_create',
+            'description':
+            dump_dict(self.description,
+                      keys=[
+                          'intrinsic_loops', 'app', 'tags', 'loops',
+                          'independent_variables', 'axis', 'config', 'entry'
+                      ])
+        })
 
-            record_id = await self._sock.recv_pyobj()
-            return Record(record_id, self.description['database'],
-                          self.description)
-        return Record(None, self.description['database'], self.description)
+        record_id = await self._sock.recv_pyobj()
+        return Record(record_id, self.description['database'],
+                      self.description)
 
     def get(self, name: str):
         if name in self.description['consts']:
@@ -481,7 +505,7 @@ class Scan():
         elif isinstance(space, OptimizeSpace):
             space.name = name
             space.optimizer.dimensions[name] = space.space
-            if space.suggestion:
+            if space.suggestion is not None:
                 space.optimizer.suggestion[name] = space.suggestion
             self._add_search_space(name, space.optimizer.level, space)
             self.add_depends(space.optimizer.name, [name])
@@ -582,8 +606,34 @@ class Scan():
             await task
             self._msg_queue.task_done()
 
+    @contextlib.asynccontextmanager
+    async def _send_msg_and_update_bar(self):
+        send_msg_task = asyncio.create_task(self._send_msg())
+        update_progress_task = asyncio.create_task(self._update_progress())
+        try:
+            yield (send_msg_task, update_progress_task)
+        finally:
+            update_progress_task.cancel()
+            send_msg_task.cancel()
+            while True:
+                try:
+                    task = self._prm_queue.get_nowait()
+                except:
+                    break
+                try:
+                    task.cancel()
+                except:
+                    pass
+
+    async def _check_background_tasks(self):
+        for task in self._background_tasks:
+            if task.done():
+                await task
+
     async def run(self):
         assymbly(self.description)
+        self._background_tasks = ()
+
         if isinstance(
                 self.description['database'],
                 str) and self.description['database'].startswith("tcp://"):
@@ -591,27 +641,17 @@ class Scan():
                                          connect=self.description['database'],
                                          socket=self._sock) as socket:
                 self._sock = socket
-                if self.config:
-                    self.description['config'] = await create_config(
-                        self.config, self.description['database'], self._sock)
-                if current_notebook() is None:
-                    await create_notebook('untitle',
-                                          self.description['database'],
-                                          self._sock)
-                cell_id = await save_input_cells(
-                    current_notebook(), self.description['entry']['scripts'],
-                    self.description['database'], self._sock)
-                self.description['entry']['scripts'] = cell_id
-                await self._run()
+                async with self._send_msg_and_update_bar() as background_tasks:
+                    self._background_tasks = background_tasks
+                    await self._run()
         else:
             if self.config:
                 self.description['config'] = copy.deepcopy(self.config)
-            await self._run()
+            async with self._send_msg_and_update_bar() as background_tasks:
+                self._background_tasks = background_tasks
+                await self._run()
 
     async def _run(self):
-        send_msg_task = asyncio.create_task(self._send_msg())
-        update_progress_task = asyncio.create_task(self._update_progress())
-
         self._variables = {'self': self, 'config': self.config}
 
         consts = {}
@@ -633,12 +673,11 @@ class Scan():
             self.description['functions'], self.variables)
         await update_variables(self.variables, updates,
                                self.description['setters'])
-
-        self.record = await self.create_record()
+        await self._check_background_tasks()
         await self.work()
         for level, bar in self._bar.items():
             bar.close()
-
+        await self._check_background_tasks()
         if self._single_step:
             self.variables.update(await call_many_functions(
                 self.description['order'].get(-1, []),
@@ -646,11 +685,9 @@ class Scan():
 
             await self.emit(0, 0, 0, self.variables)
             await self.emit(-1, 0, 0, {})
-
+        await self._check_background_tasks()
         await self._prm_queue.join()
-        update_progress_task.cancel()
         await self._msg_queue.join()
-        send_msg_task.cancel()
         return self.variables
 
     async def done(self):
@@ -712,6 +749,7 @@ class Scan():
                 | {'config': self._synchronize_config},
                 self.description['optimizers'], self.description['setters'],
                 self.description['getters']):
+            await self._check_background_tasks()
             self._current_level += 1
             if await self._filter(variables, self.current_level - 1):
                 yield variables
@@ -723,11 +761,13 @@ class Scan():
             self._current_level -= 1
             self._prm_queue.put_nowait(
                 self._update_progress_bar(self.current_level, 1))
+            await self._check_background_tasks()
         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
+            await self._check_background_tasks()
             await self._prm_queue.join()
 
     async def work(self, **kwds):
@@ -776,10 +816,10 @@ class Scan():
                 buf = dill.dumps((awaitable, args, kwds))
                 task = asyncio.get_running_loop().run_in_executor(
                     self._executors, _run_function_in_process, buf)
-                self._prm_queue.put_nowait(task)
-                return Promise(task)
             except:
                 return awaitable(*args, **kwds)
+            self._prm_queue.put_nowait(task)
+            return Promise(task)
         else:
             return awaitable
 
@@ -788,7 +828,7 @@ class Scan():
             return await awaitable
 
 
-def assymbly(description):
+def _get_environment(description):
     import __main__
     from IPython import get_ipython
 
@@ -818,6 +858,10 @@ def assymbly(description):
 
     description['entry']['env'] = {k: v for k, v in os.environ.items()}
 
+    return description
+
+
+def _mapping_levels(description):
     mapping = {
         label: level
         for level, label in enumerate(
@@ -850,8 +894,23 @@ def assymbly(description):
                                                   len(space))
             except:
                 pass
+    return levels
+
+
+def _get_independent_variables(description):
+    independent_variables = set(description['intrinsic_loops'].keys())
+    for level, loops in description['loops'].items():
+        for name, iterable in loops:
+            if isinstance(iterable, (np.ndarray, list, tuple, range, Space)):
+                independent_variables.add(name)
+    return independent_variables
+
 
+def _build_dependents(description, levels, independent_variables):
     dependents = copy.deepcopy(description['dependents'])
+    all_nodes = set(description['dependents'].keys())
+    for key, deps in dependents.items():
+        all_nodes.update(deps)
 
     for level in levels:
         range_list = description['loops'].get(level, [])
@@ -864,6 +923,13 @@ def assymbly(description):
                 dependents[name] = set()
             dependents[name].add(f'#__loop_{level}')
 
+    after_yield = set()
+    for key in all_nodes:
+        if key not in independent_variables and key not in description[
+                'consts']:
+            if key not in dependents:
+                after_yield.add(key)
+
     def _get_all_depends(key, graph):
         ret = set()
         if key not in graph:
@@ -877,7 +943,13 @@ def assymbly(description):
     full_depends = {}
     for key in dependents:
         full_depends[key] = _get_all_depends(key, dependents)
+        if full_depends[key] & after_yield:
+            after_yield.add(key)
+
+    return dependents, full_depends, after_yield
+
 
+def _build_order(description, levels, dependents, full_depends):
     levels = {}
     passed = set()
     all_keys = set(description['consts'].keys())
@@ -922,8 +994,9 @@ def assymbly(description):
                 description['order'][level].append(ready)
                 keys -= set(ready)
 
+
+def _make_axis(description):
     axis = {}
-    independent_variables = set(description['intrinsic_loops'].keys())
 
     for name in description['consts']:
         axis[name] = ()
@@ -932,8 +1005,6 @@ def assymbly(description):
             if isinstance(iterable, OptimizeSpace):
                 axis[name] = tuple(range(level + 1))
                 continue
-            elif isinstance(iterable, (np.ndarray, list, tuple, range, Space)):
-                independent_variables.add(name)
             axis[name] = (level, )
 
     for level, group in description['order'].items():
@@ -954,8 +1025,20 @@ def assymbly(description):
         k: tuple([x for x in v if x >= 0])
         for k, v in axis.items()
     }
+
+
+def assymbly(description):
+    _get_environment(description)
+    levels = _mapping_levels(description)
+    independent_variables = _get_independent_variables(description)
     description['independent_variables'] = independent_variables
 
+    dependents, full_depends, after_yield = _build_dependents(
+        description, levels, independent_variables)
+
+    _build_order(description, levels, dependents, full_depends)
+    _make_axis(description)
+
     return description
 
 

qulab/scan/server.py

@@ -1,6 +1,8 @@
 import asyncio
 import os
 import pickle
+import subprocess
+import sys
 import time
 import uuid
 from pathlib import Path
@@ -18,6 +20,7 @@ from .models import Cell, Notebook
 from .models import Record as RecordInDB
 from .models import Session, create_engine, create_tables, sessionmaker, utcnow
 from .record import BufferList, Record, random_path
+from .utils import dump_dict, load_dict
 
 try:
     default_record_port = int(os.getenv('QULAB_RECORD_PORT', 6789))
@@ -51,6 +54,16 @@ class Request():
         return f"Request({self.method})"
 
 
+class Response():
+    pass
+
+
+class ErrorResponse(Response):
+
+    def __init__(self, error):
+        self.error = error
+
+
 async def reply(req, resp):
     await req.sock.send_multipart([req.identity, pickle.dumps(resp)])
 
@@ -59,33 +72,45 @@ def clear_cache():
     if len(record_cache) < CACHE_SIZE:
         return
 
+    logger.debug(f"clear_cache record_cache: {len(record_cache)}")
     for k, (t, _) in zip(sorted(record_cache.items(), key=lambda x: x[1][0]),
                          range(len(record_cache) - CACHE_SIZE)):
         del record_cache[k]
 
+    logger.debug(f"clear_cache buffer_list_cache: {len(buffer_list_cache)}")
     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]
+    logger.debug(f"clear_cache done.")
 
 
 def flush_cache():
+    logger.debug(f"flush_cache: {len(record_cache)}")
     for k, (t, r) in record_cache.items():
         r.flush()
+    logger.debug(f"flush_cache done.")
 
 
 def get_local_record(session: Session, id: int, datapath: Path) -> Record:
+    logger.debug(f"get_local_record: {id}")
     record_in_db = session.get(RecordInDB, id)
     if record_in_db is None:
+        logger.debug(f"record not found: {id=}")
         return None
     record_in_db.atime = utcnow()
 
     if record_in_db.file.endswith('.zip'):
-        return Record.load(datapath / 'objects' / record_in_db.file)
+        logger.debug(f"load record from zip: {record_in_db.file}")
+        record = Record.load(datapath / 'objects' / record_in_db.file)
+        logger.debug(f"load record from zip done.")
+        return record
 
     path = datapath / 'objects' / record_in_db.file
     with open(path, 'rb') as f:
+        logger.debug(f"load record from file: {path}")
         record = dill.load(f)
+        logger.debug(f"load record from file done.")
         record.database = datapath
         record._file = path
     return record
@@ -95,13 +120,16 @@ def get_record(session: Session, id: int, datapath: Path) -> Record:
     if id not in record_cache:
         record = get_local_record(session, id, datapath)
     else:
+        logger.debug(f"get_record from cache: {id=}")
         record = record_cache[id][1]
     clear_cache()
+    logger.debug(f"update lru time for record cache: {id=}")
     record_cache[id] = time.time(), record
     return record
 
 
 def record_create(session: Session, description: dict, datapath: Path) -> int:
+    logger.debug(f"record_create: {description['app']}")
     record = Record(None, datapath, description)
     record_in_db = RecordInDB()
     if 'app' in description:
@@ -111,28 +139,39 @@ def record_create(session: Session, description: dict, datapath: Path) -> int:
     record_in_db.file = '/'.join(record._file.parts[-4:])
     record_in_db.config_id = description['config']
     record._file = datapath / 'objects' / record_in_db.file
+    logger.debug(f"record_create generate random file: {record_in_db.file}")
     session.add(record_in_db)
     try:
         session.commit()
+        logger.debug(f"record_create commited: record.id={record_in_db.id}")
         record.id = record_in_db.id
         clear_cache()
         record_cache[record.id] = time.time(), record
         return record.id
     except:
+        logger.debug(f"record_create rollback")
         session.rollback()
         raise
 
 
 def record_append(session: Session, record_id: int, level: int, step: int,
                   position: int, variables: dict, datapath: Path):
+    logger.debug(f"record_append: {record_id}")
     record = get_record(session, record_id, datapath)
+    logger.debug(f"record_append: {record_id}, {level}, {step}, {position}")
     record.append(level, step, position, variables)
+    logger.debug(f"record_append done.")
     try:
+        logger.debug(f"record_append update SQL database.")
         record_in_db = session.get(RecordInDB, record_id)
+        logger.debug(f"record_append get RecordInDB: {record_in_db}")
         record_in_db.mtime = utcnow()
         record_in_db.atime = utcnow()
+        logger.debug(f"record_append update RecordInDB: {record_in_db}")
         session.commit()
+        logger.debug(f"record_append commited.")
     except:
+        logger.debug(f"record_append rollback.")
         session.rollback()
         raise
 
@@ -145,16 +184,20 @@ def record_delete(session: Session, record_id: int, datapath: Path):
     session.commit()
 
 
-@logger.catch
+@logger.catch(reraise=True)
 async def handle(session: Session, request: Request, datapath: Path):
 
     msg = request.msg
 
+    if request.method not in ['ping']:
+        logger.debug(f"handle: {request.method}")
+
     match request.method:
         case 'ping':
             await reply(request, 'pong')
         case 'bufferlist_iter':
-            if msg['iter_id'] in buffer_list_cache:
+            logger.debug(f"bufferlist_iter: {msg}")
+            if msg['iter_id'] and msg['iter_id'] in buffer_list_cache:
                 it = buffer_list_cache[msg['iter_id']][1]
                 iter_id = msg['iter_id']
             else:
@@ -174,22 +217,30 @@ async def handle(session: Session, request: Request, datapath: Path):
                 except StopIteration:
                     end = True
                     break
+            logger.debug(f"bufferlist_iter: {iter_id}, {end}")
             await reply(request, (iter_id, ret, end))
+            logger.debug(f"reply bufferlist_iter: {iter_id}, {end}")
             buffer_list_cache[iter_id] = time.time(), it
             clear_cache()
         case 'bufferlist_iter_exit':
+            logger.debug(f"bufferlist_iter_exit: {msg}")
             try:
                 it = buffer_list_cache.pop(msg['iter_id'])[1]
                 it.throw(Exception)
             except:
                 pass
             clear_cache()
+            logger.debug(f"end bufferlist_iter_exit: {msg}")
         case 'record_create':
-            description = dill.loads(msg['description'])
+            logger.debug(f"record_create")
+            description = load_dict(msg['description'])
             await reply(request, record_create(session, description, datapath))
+            logger.debug(f"reply record_create")
         case 'record_append':
+            logger.debug(f"record_append")
             record_append(session, msg['record_id'], msg['level'], msg['step'],
                           msg['position'], msg['variables'], datapath)
+            logger.debug(f"reply record_append")
         case 'record_description':
             record = get_record(session, msg['record_id'], datapath)
             await reply(request, dill.dumps(record))
@@ -295,6 +346,9 @@ async def handle(session: Session, request: Request, datapath: Path):
         case _:
             logger.error(f"Unknown method: {msg['method']}")
 
+    if request.method not in ['ping']:
+        logger.debug(f"finished handle: {request.method}")
+
 
 async def handle_with_timeout(session: Session, request: Request,
                               datapath: Path, timeout: float):
@@ -306,35 +360,45 @@ async def handle_with_timeout(session: Session, request: Request,
             f"Task handling request {request} timed out and was cancelled.")
         await reply(request, 'timeout')
     except Exception as e:
-        await reply(request, f'{e!r}')
+        logger.error(f"Task handling request {request} failed: {e!r}")
+        await reply(request, ErrorResponse(f'{e!r}'))
+    logger.debug(f"Task handling request {request} finished.")
 
 
 async def serv(port,
                datapath,
-               url=None,
+               url='',
                buffer_size=1024 * 1024 * 1024,
                interval=60):
-    logger.info('Server starting.')
+    logger.debug('Creating socket...')
     async with ZMQContextManager(zmq.ROUTER, bind=f"tcp://*:{port}") as sock:
-        if url is None:
+        logger.info(f'Server started at port {port}.')
+        logger.info(f'Data path: {datapath}.')
+        if not url or url == 'sqlite':
             url = 'sqlite:///' + str(datapath / 'data.db')
         engine = create_engine(url)
         create_tables(engine)
         Session = sessionmaker(engine)
         with Session() as session:
-            logger.info('Server started.')
+            logger.info(f'Database connected: {url}.')
             received = 0
             last_flush_time = time.time()
             while True:
+                logger.debug('Waiting for request...')
                 identity, msg = await sock.recv_multipart()
+                logger.debug('Received request.')
                 received += len(msg)
                 try:
                     req = Request(sock, identity, msg)
-                except:
+                except Exception as e:
                     logger.exception('bad request')
+                    await sock.send_multipart(
+                        [identity,
+                         pickle.dumps(ErrorResponse(f'{e!r}'))])
                     continue
                 asyncio.create_task(
-                    handle_with_timeout(session, req, datapath, timeout=60.0))
+                    handle_with_timeout(session, req, datapath,
+                                        timeout=3600.0))
                 if received > buffer_size or time.time(
                 ) - last_flush_time > interval:
                     flush_cache()
@@ -342,46 +406,123 @@ async def serv(port,
                     last_flush_time = time.time()
 
 
-async def watch(port, datapath, url=None, timeout=1, buffer=1024, interval=60):
-    with ZMQContextManager(zmq.DEALER,
-                           connect=f"tcp://127.0.0.1:{port}") as sock:
-        sock.setsockopt(zmq.LINGER, 0)
+async def main(port,
+               datapath,
+               url,
+               timeout=1,
+               buffer=1024,
+               interval=60,
+               log='stderr',
+               no_watch=True,
+               debug=False):
+    if no_watch:
+        logger.remove()
+        if debug:
+            level = 'DEBUG'
+        else:
+            level = 'INFO'
+        if log == 'stderr':
+            logger.add(sys.stderr, level=level)
+        elif log == 'stdout':
+            logger.add(sys.stdout, level=level)
+        else:
+            logger.add(sys.stderr, level=level)
+            logger.add(log, level=level)
+        logger.debug(f"logging level: {level}")
+        logger.info('Server starting...')
+        await serv(port, datapath, url, buffer * 1024 * 1024, interval)
+    else:
+        process = None
+
         while True:
             try:
-                sock.send_pyobj({"method": "ping"})
-                if sock.poll(int(1000 * timeout)):
-                    sock.recv()
-                else:
-                    raise asyncio.TimeoutError()
+                with ZMQContextManager(
+                        zmq.DEALER, connect=f"tcp://127.0.0.1:{port}") as sock:
+                    sock.setsockopt(zmq.LINGER, 0)
+                    sock.send_pyobj({"method": "ping"})
+                    logger.debug('ping.')
+                    if sock.poll(int(1000 * timeout)):
+                        sock.recv()
+                        logger.debug('recv pong.')
+                    else:
+                        logger.debug('timeout.')
+                        raise asyncio.TimeoutError()
             except (zmq.error.ZMQError, asyncio.TimeoutError):
-                return asyncio.create_task(
-                    serv(port, datapath, url, buffer * 1024 * 1024, interval))
+                if process is not None:
+                    logger.debug(
+                        f'killing process... PID={process.pid}, returncode={process.returncode}'
+                    )
+                    process.kill()
+                    logger.debug(
+                        f'killed process. PID={process.pid}, returncode={process.returncode}'
+                    )
+                cmd = [
+                    sys.executable,
+                    "-m",
+                    "qulab",
+                    "server",
+                    "--port",
+                    f"{port}",
+                    "--datapath",
+                    f"{datapath}",
+                    "--url",
+                    f"{url}",
+                    "--timeout",
+                    f"{timeout}",
+                    "--buffer",
+                    f"{buffer}",
+                    "--interval",
+                    f"{interval}",
+                    "--log",
+                    f"{log}",
+                ]
+                if url:
+                    cmd.extend(['--url', url])
+                if debug:
+                    cmd.append('--debug')
+                cmd.append("--no-watch")
+                logger.debug(f"starting process: {' '.join(cmd)}")
+                process = subprocess.Popen(cmd, cwd=os.getcwd())
+                logger.debug(
+                    f'process started. PID={process.pid}, returncode={process.returncode}'
+                )
+
+                # Capture and log the output
+                # stdout, stderr = process.communicate(timeout=5)
+                # if stdout:
+                #     logger.info(f'Server stdout: {stdout.decode()}')
+                # if stderr:
+                #     logger.error(f'Server stderr: {stderr.decode()}')
+
+                await asyncio.sleep(5)
             await asyncio.sleep(timeout)
 
 
-async def main(port, datapath, url, timeout=1, buffer=1024, interval=60):
-    task = await watch(port=port,
-                       datapath=datapath,
-                       url=url,
-                       timeout=timeout,
-                       buffer=buffer,
-                       interval=interval)
-    await task
-
-
 @click.command()
 @click.option('--port',
               default=os.getenv('QULAB_RECORD_PORT', 6789),
               help='Port of the server.')
 @click.option('--datapath', default=datapath, help='Path of the data.')
-@click.option('--url', default=None, help='URL of the database.')
+@click.option('--url', default='sqlite', help='URL of the database.')
 @click.option('--timeout', default=1, help='Timeout of ping.')
 @click.option('--buffer', default=1024, help='Buffer size (MB).')
 @click.option('--interval',
               default=60,
               help='Interval of flush cache, in unit of second.')
-def server(port, datapath, url, timeout, buffer, interval):
-    asyncio.run(main(port, Path(datapath), url, timeout, buffer, interval))
+@click.option('--log', default='stderr', help='Log file.')
+@click.option('--no-watch', is_flag=True, help='Watch the server.')
+@click.option('--debug', is_flag=True, help='Debug mode.')
+def server(port, datapath, url, timeout, buffer, interval, log, no_watch,
+           debug):
+    try:
+        import uvloop
+        uvloop.run(
+            main(port, Path(datapath), url, timeout, buffer, interval, log,
+                 True, debug))
+    except ImportError:
+        asyncio.run(
+            main(port, Path(datapath), url, timeout, buffer, interval, log,
+                 True, debug))
 
 
 if __name__ == "__main__":

qulab/scan/utils.py

@@ -29,6 +29,46 @@ class TooLarge:
         return f'<TooLarge: {self.type} at 0x{id(self):x}>'
 
 
+def dump_dict(d, keys=[]):
+    ret = {}
+
+    for key, value in d.items():
+        if key in keys:
+            ret[key] = value
+            continue
+        if isinstance(value, dict) and isinstance(key, str):
+            ret[key] = dump_dict(value,
+                                 keys=[
+                                     k[len(key) + 1:] for k in keys
+                                     if k.startswith(f'{key}.')
+                                 ])
+        else:
+            try:
+                ret[key] = dill.dumps(value)
+            except:
+                ret[key] = Unpicklable(value)
+
+    return dill.dumps(ret)
+
+
+def load_dict(buff):
+    if isinstance(buff, dict):
+        return {key: load_dict(value) for key, value in buff.items()}
+
+    if not isinstance(buff, bytes):
+        return buff
+
+    try:
+        ret = dill.loads(buff)
+    except:
+        return buff
+
+    if isinstance(ret, dict):
+        return load_dict(ret)
+    else:
+        return ret
+
+
 def dump_globals(ns=None, *, size_limit=10 * 1024 * 1024, warn=False):
     import __main__
 

qulab/version.py

@@ -1 +1 @@
-__version__ = "2.3.2"
+__version__ = "2.3.4"