QuLab 2.3.4__cp310-cp310-win_amd64.whl → 2.3.5__cp310-cp310-win_amd64.whl

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

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

{QuLab-2.3.4.dist-info → QuLab-2.3.5.dist-info}/RECORD

@@ -1,7 +1,7 @@
 qulab/__init__.py,sha256=vkFybY8YSsQilYdThPRD83-btPAR41sy_WCXiM-6mME,141
 qulab/__main__.py,sha256=V7iokU7awstgjCeiF_hoOdFyrqJwC_4QetiLe7cWvOQ,454
-qulab/fun.cp310-win_amd64.pyd,sha256=yXg9m-zMCW4lYJYIT-YlLePyJPQaU3YJN6B3Y77jlpk,31744
-qulab/version.py,sha256=MtmOJMh3yHY9aTdRsZDgbpPfbzm9xdycdi9jjMKzYjM,21
+qulab/fun.cp310-win_amd64.pyd,sha256=kQuRgdvK9lRtsFCBDRU6U9Ujcd1KTbrsozcQCkZoYL4,31744
+qulab/version.py,sha256=ctNy09QkNipfMu2fxyFBsAXtRoAHMP1bEKHsc3zRmkk,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
@@ -16,13 +16,13 @@ qulab/scan/__init__.py,sha256=RR_0NQcr8Mi3vpWdypydbijQ1rXA0D3DEidQ7xjNslM,133
 qulab/scan/curd.py,sha256=yaTglGiS6mlk0GqDHi_w8T02XGBMvDZtXSdML7zDywk,7117
 qulab/scan/expression.py,sha256=l7TYBmcJIo0M5GJm1TtrkrMFj5mCmrfLOMCILKbOivU,20712
 qulab/scan/models.py,sha256=ZvXkJEt5Yz3Sjx0JKzYka-q2Uo-w_iVzHgH8A6DbjF0,18236
-qulab/scan/optimize.py,sha256=ACfGSfrFpPgmZo_P5kD4mquahXImYipdP7E86dtFQO8,2635
+qulab/scan/optimize.py,sha256=zOR4Wp96bLarTSiPJ-cTAfT-V_MU-YEgB-XqYsBhS30,2637
 qulab/scan/query.py,sha256=RM8bG4Tcx_PaNk8tv9HdlTZ1dGuuSr3sZVkYVq2BtfQ,12183
 qulab/scan/record.py,sha256=MVmxhIzwmOju7eWxJEWsqJZlVgrDeRXGMfNvXImj7Ms,21883
-qulab/scan/scan.py,sha256=PDU0oZkwCntucOM4aNNgY22t-Ng8XChmFrhTqPqxDX8,41814
-qulab/scan/server.py,sha256=ahdVpTKm8P2qB7E9HKM8b95HF89YlCJ5WWLmdJhMfgw,20479
-qulab/scan/space.py,sha256=S-jHaXXf12FzjajOhPsZ-mkpGzAxrFAI3tRuQrvTBKg,6274
-qulab/scan/utils.py,sha256=j5ai6E-pK2tYEPYlL1FpgHG7q2DL1IVAa-hPPgz5SlQ,4757
+qulab/scan/scan.py,sha256=p7LZvmjDSnUHeszgILlEXFIspHVPLk9Rt2dVqFtNsaQ,40645
+qulab/scan/server.py,sha256=iT9wMEUQ2Pz_5nioHA7nII1MBPpQi-rCFbEJnRdWkDg,20487
+qulab/scan/space.py,sha256=t8caa_gKlnhaAIEksJyxINUTecOS7lMWAz1HDKlVcds,6909
+qulab/scan/utils.py,sha256=YXFA19HEakHB5TaPOU9CjQ1Lc3GUJaSIGOtiWjAWsG4,6353
 qulab/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/storage/__main__.py,sha256=6-EjN0waX1yfcMPJXqpIr9UlrIEsSCFApm5G-ZeaPMQ,1742
 qulab/storage/base_dataset.py,sha256=28y3-OZrqJ52p5sbirEpUgjb7hqwLLpd38KU9DCkD24,12217
@@ -78,9 +78,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.3.4.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
-QuLab-2.3.4.dist-info/METADATA,sha256=t-ZisaizQKo8edK0p_-vQD8ljsuXo9cl2dg5wE-sFsU,3735
-QuLab-2.3.4.dist-info/WHEEL,sha256=H-K32IiNZYCPWcWlZi7cxr5Zu8ogRQGVOyOK_jygsF0,101
-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-2.3.5.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
+QuLab-2.3.5.dist-info/METADATA,sha256=CUbsOaCfpAwZ7tf7MIywKpb0DuidIos4u6sMgE2PXKs,3735
+QuLab-2.3.5.dist-info/WHEEL,sha256=tF77PxuEGG-2kyJBah3Kgju_42iEyT5AcvsT_0Dgcj0,101
+QuLab-2.3.5.dist-info/entry_points.txt,sha256=ohBzutEnQimP_BZWiuXdSliu4QAYSHHcN0PZD8c7ZCY,46
+QuLab-2.3.5.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+QuLab-2.3.5.dist-info/RECORD,,

{QuLab-2.3.4.dist-info → QuLab-2.3.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.1.0)
+Generator: setuptools (71.0.0)
 Root-Is-Purelib: false
 Tag: cp310-cp310-win_amd64
 

qulab/scan/optimize.py

@@ -72,5 +72,5 @@ class NgOptimizer():
         if history:
             ret.x_iters = self._all_x
             ret.func_vals = self._all_y
-        ret.fun = recommendation.value
+        # ret.fun = recommendation.value
         return ret

qulab/scan/scan.py

@@ -6,9 +6,7 @@ import itertools
 import lzma
 import os
 import pickle
-import platform
 import re
-import subprocess
 import sys
 import uuid
 from concurrent.futures import ProcessPoolExecutor
@@ -26,7 +24,8 @@ 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_dict, dump_globals
+from .utils import (async_zip, call_function, dump_dict, dump_globals,
+                    get_installed_packages, get_system_info, yapf_reformat)
 
 try:
     from tqdm.notebook import tqdm
@@ -58,57 +57,34 @@ else:
     default_executor = default_server
 
 
-def yapf_reformat(cell_text):
-    try:
-        import isort
-        import yapf.yapflib.yapf_api
-
-        fname = f"f{uuid.uuid1().hex}"
-
-        def wrap(source):
-            lines = [f"async def {fname}():"]
-            for line in source.split('\n'):
-                lines.append("    " + line)
-            return '\n'.join(lines)
+class Promise():
+    __slots__ = ['task', 'key', 'attr']
 
-        def unwrap(source):
-            lines = []
-            for line in source.split('\n'):
-                if line.startswith(f"async def {fname}():"):
-                    continue
-                lines.append(line[4:])
-            return '\n'.join(lines)
+    def __init__(self, task, key=None, attr=None):
+        self.task = task
+        self.key = key
+        self.attr = attr
 
-        cell_text = re.sub('^%', '#%#', cell_text, flags=re.M)
-        reformated_text = unwrap(
-            yapf.yapflib.yapf_api.FormatCode(wrap(isort.code(cell_text)))[0])
-        return re.sub('^#%#', '%', reformated_text, flags=re.M)
-    except:
-        return cell_text
+    def __await__(self):
 
+        async def _getitem(task, key):
+            return (await task)[key]
 
-def get_installed_packages():
-    result = subprocess.run([sys.executable, '-m', 'pip', 'freeze'],
-                            stdout=subprocess.PIPE,
-                            text=True)
+        async def _getattr(task, attr):
+            return getattr(await task, attr)
 
-    lines = result.stdout.split('\n')
-    packages = []
-    for line in lines:
-        if line:
-            packages.append(line)
-    return packages
+        if self.key is not None:
+            return _getitem(self.task, self.key).__await__()
+        elif self.attr is not None:
+            return _getattr(self.task, self.attr).__await__()
+        else:
+            return self.task.__await__()
 
+    def __getitem__(self, key):
+        return Promise(self.task, key, None)
 
-def get_system_info():
-    info = {
-        'OS': platform.uname()._asdict(),
-        'Python': sys.version,
-        'PythonExecutable': sys.executable,
-        'PythonPath': sys.path,
-        'packages': get_installed_packages()
-    }
-    return info
+    def __getattr__(self, attr):
+        return Promise(self.task, None, attr)
 
 
 def current_notebook():
@@ -170,39 +146,185 @@ def _get_depends(func: Callable):
     return args
 
 
-class Promise():
-    __slots__ = ['task', 'key', 'attr']
+def _run_function_in_process(buf):
+    func, args, kwds = dill.loads(buf)
+    return func(*args, **kwds)
 
-    def __init__(self, task, key=None, attr=None):
-        self.task = task
-        self.key = key
-        self.attr = attr
 
-    def __await__(self):
+async def update_variables(variables: dict[str, Any], updates: dict[str, Any],
+                           setters: dict[str, Callable]):
+    coros = []
+    for name, value in updates.items():
+        if name in setters:
+            coro = setters[name](value)
+            if inspect.isawaitable(coro):
+                coros.append(coro)
+        variables[name] = value
+    if coros:
+        await asyncio.gather(*coros)
 
-        async def _getitem(task, key):
-            return (await task)[key]
 
-        async def _getattr(task, attr):
-            return getattr(await task, attr)
+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],
+                      setters: dict[str, Callable] = {},
+                      getters: dict[str, Callable] = {}):
+    iters_d = {}
+    env = Env()
+    env.variables = variables
+    opts = {}
 
-        if self.key is not None:
-            return _getitem(self.task, self.key).__await__()
-        elif self.attr is not None:
-            return _getattr(self.task, self.attr).__await__()
+    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 isinstance(iter, Space):
+            iters_d[name] = iter.toarray()
+        elif callable(iter):
+            iters_d[name] = await call_function(iter, variables)
         else:
-            return self.task.__await__()
+            iters_d[name] = iter
 
-    def __getitem__(self, key):
-        return Promise(self.task, key, None)
+    maxiter = 0xffffffff
+    for name, opt in opts.items():
+        opt_cfg = optimizers[name]
+        maxiter = min(maxiter, opt_cfg.maxiter)
 
-    def __getattr__(self, attr):
-        return Promise(self.task, None, attr)
+    async for args in async_zip(*iters_d.values(), range(maxiter)):
+        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]
+            await update_variables(variables, {
+                n: v
+                for n, v in zip(opt_cfg.dimensions.keys(), args)
+            }, setters)
+
+        await update_variables(
+            variables, await call_many_functions(order, functions, variables),
+            setters)
 
+        yield variables
 
-def _run_function_in_process(buf):
-    func, args, kwds = dill.loads(buf)
-    return func(*args, **kwds)
+        variables.update(await call_many_functions(order, getters, variables))
+
+        if opts:
+            for key in list(variables.keys()):
+                if key.startswith('*') or ',' in key:
+                    await _unpack(key, 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)
+
+    if opts:
+        for name, opt in opts.items():
+            opt_cfg = optimizers[name]
+            result = opt.get_result()
+            await update_variables(
+                variables, {
+                    name: value
+                    for name, value in zip(opt_cfg.dimensions.keys(), result.x)
+                }, setters)
+
+        yield variables
+
+        variables.update(await call_many_functions(order, getters, variables))
+
+        for key in list(variables.keys()):
+            if key.startswith('*') or ',' in key:
+                await _unpack(key, variables)
+
+
+async def call_many_functions(order: list[list[str]],
+                              functions: dict[str, Callable],
+                              variables: dict[str, Any]) -> dict[str, Any]:
+    ret = {}
+    for group in order:
+        waited = []
+        coros = []
+        for name in group:
+            if name in functions:
+                waited.append(name)
+                coros.append(call_function(functions[name], variables | ret))
+        if coros:
+            results = await asyncio.gather(*coros)
+            ret.update(dict(zip(waited, results)))
+    return ret
+
+
+async def _unpack(key, variables):
+    x = variables[key]
+    if inspect.isawaitable(x):
+        x = await x
+    if key.startswith('**'):
+        assert isinstance(
+            x, dict), f"Should promise a dict for `**` symbol. {key}"
+        if "{key}" in key:
+            for k, v in x.items():
+                variables[key[2:].format(key=k)] = v
+        else:
+            variables.update(x)
+    elif key.startswith('*'):
+        assert isinstance(
+            x, (list, tuple,
+                np.ndarray)), f"Should promise a list for `*` symbol. {key}"
+        for i, v in enumerate(x):
+            k = key[1:].format(i=i)
+            variables[k] = v
+    elif ',' in key:
+        keys1, keys2 = [], []
+        args = None
+        for k in key.split(','):
+            if k.startswith('*'):
+                if args is None:
+                    args = k
+                else:
+                    raise ValueError(f'Only one `*` symbol is allowed. {key}')
+            elif args is None:
+                keys1.append(k)
+            else:
+                keys2.append(k)
+        assert isinstance(
+            x,
+            (list, tuple,
+             np.ndarray)), f"Should promise a list for multiple symbols. {key}"
+        if args is None:
+            assert len(keys1) == len(
+                x), f"Length of keys and values should be equal. {key}"
+            for k, v in zip(keys1, x):
+                variables[k] = v
+        else:
+            assert len(keys1) + len(keys2) <= len(
+                x), f"Too many values for unpacking. {key}"
+            for k, v in zip(keys1, x[:len(keys1)]):
+                variables[k] = v
+            end = -len(keys2) if keys2 else None
+            for i, v in enumerate(x[len(keys1):end]):
+                k = args[1:].format(i=i)
+                variables[k] = v
+            if keys2:
+                for k, v in zip(keys2, x[end:]):
+                    variables[k] = v
+    else:
+        return
+    del variables[key]
 
 
 class Scan():
@@ -232,6 +354,7 @@ class Scan():
         self.id = task_uuid()
         self.record = None
         self.config = {} if config is None else copy.deepcopy(config)
+        self._raw_config_copy = copy.deepcopy(self.config)
         self.description = {
             'app': app,
             'tags': tags,
@@ -252,7 +375,7 @@ class Scan():
             'filters': {},
             'total': {},
             'database': database,
-            'hiden': ['self', 'config', r'^__.*', r'.*__$'],
+            'hiden': ['self', 'config', r'^__.*', r'.*__$', r'^#.*'],
             'entry': {
                 'system': get_system_info(),
                 'env': {},
@@ -386,7 +509,7 @@ class Scan():
 
         if self.config:
             self.description['config'] = await create_config(
-                self.config, self.description['database'], self._sock)
+                self._raw_config_copy, self.description['database'], self._sock)
         if current_notebook() is None:
             await create_notebook('untitle', self.description['database'],
                                   self._sock)
@@ -464,9 +587,9 @@ class Scan():
             if depends:
                 self.add_depends(name, depends)
                 s = ','.join(depends)
-                self.description['functions'][f'_tmp_{name}'] = value
+                self.description['functions'][f'#{name}'] = value
                 self.description['functions'][name] = eval(
-                    f"lambda self, {s}: self.description['functions']['_tmp_{name}']({s})"
+                    f"lambda self, {s}: self.description['functions']['#{name}']({s})"
                 )
             else:
                 self.add_depends(name, _get_depends(value))
@@ -646,7 +769,7 @@ class Scan():
                     await self._run()
         else:
             if self.config:
-                self.description['config'] = copy.deepcopy(self.config)
+                self.description['config'] = self._raw_config_copy
             async with self._send_msg_and_update_bar() as background_tasks:
                 self._background_tasks = background_tasks
                 await self._run()
@@ -1040,173 +1163,4 @@ def assymbly(description):
     _make_axis(description)
 
     return description
-
-
-async def update_variables(variables: dict[str, Any], updates: dict[str, Any],
-                           setters: dict[str, Callable]):
-    coros = []
-    for name, value in updates.items():
-        if name in setters:
-            coro = setters[name](value)
-            if inspect.isawaitable(coro):
-                coros.append(coro)
-        variables[name] = value
-    if coros:
-        await asyncio.gather(*coros)
-
-
-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],
-                      setters: dict[str, Callable] = {},
-                      getters: dict[str, Callable] = {}):
-    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 isinstance(iter, Space):
-            iters_d[name] = iter.toarray()
-        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)):
-        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]
-            await update_variables(variables, {
-                n: v
-                for n, v in zip(opt_cfg.dimensions.keys(), args)
-            }, setters)
-
-        await update_variables(
-            variables, await call_many_functions(order, functions, variables),
-            setters)
-
-        yield variables
-
-        variables.update(await call_many_functions(order, getters, variables))
-
-        if opts:
-            for key in list(variables.keys()):
-                if key.startswith('*') or ',' in key:
-                    await _unpack(key, 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()
-        await update_variables(
-            variables, {
-                name: value
-                for name, value in zip(opt_cfg.dimensions.keys(), result.x)
-            }, setters)
-        variables[name] = result.fun
-    if opts:
-        yield variables
-
-
-async def call_many_functions(order: list[list[str]],
-                              functions: dict[str, Callable],
-                              variables: dict[str, Any]) -> dict[str, Any]:
-    ret = {}
-    for group in order:
-        waited = []
-        coros = []
-        for name in group:
-            if name in functions:
-                waited.append(name)
-                coros.append(call_function(functions[name], variables | ret))
-        if coros:
-            results = await asyncio.gather(*coros)
-            ret.update(dict(zip(waited, results)))
-    return ret
-
-
-async def _unpack(key, variables):
-    x = variables[key]
-    if inspect.isawaitable(x):
-        x = await x
-    if key.startswith('**'):
-        assert isinstance(
-            x, dict), f"Should promise a dict for `**` symbol. {key}"
-        if "{key}" in key:
-            for k, v in x.items():
-                variables[key[2:].format(key=k)] = v
-        else:
-            variables.update(x)
-    elif key.startswith('*'):
-        assert isinstance(
-            x, (list, tuple,
-                np.ndarray)), f"Should promise a list for `*` symbol. {key}"
-        for i, v in enumerate(x):
-            k = key[1:].format(i=i)
-            variables[k] = v
-    elif ',' in key:
-        keys1, keys2 = [], []
-        args = None
-        for k in key.split(','):
-            if k.startswith('*'):
-                if args is None:
-                    args = k
-                else:
-                    raise ValueError(f'Only one `*` symbol is allowed. {key}')
-            elif args is None:
-                keys1.append(k)
-            else:
-                keys2.append(k)
-        assert isinstance(
-            x,
-            (list, tuple,
-             np.ndarray)), f"Should promise a list for multiple symbols. {key}"
-        if args is None:
-            assert len(keys1) == len(
-                x), f"Length of keys and values should be equal. {key}"
-            for k, v in zip(keys1, x):
-                variables[k] = v
-        else:
-            assert len(keys1) + len(keys2) <= len(
-                x), f"Too many values for unpacking. {key}"
-            for k, v in zip(keys1, x[:len(keys1)]):
-                variables[k] = v
-            end = -len(keys2) if keys2 else None
-            for i, v in enumerate(x[len(keys1):end]):
-                k = args[1:].format(i=i)
-                variables[k] = v
-            if keys2:
-                for k, v in zip(keys2, x[end:]):
-                    variables[k] = v
-    else:
-        return
-    del variables[key]
+    return description

qulab/scan/server.py

@@ -73,14 +73,15 @@ def clear_cache():
         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)):
+    for (k, (t, r),
+         i) 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)):
+    for (k, (t, r),
+         i) 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.")
 

qulab/scan/space.py

@@ -25,12 +25,27 @@ class Space():
 
     @classmethod
     def fromarray(cls, space):
-        if isinstance(space, Space):
+        if isinstance(space, (Space, range, enumerate, tuple)):
             return space
-        if isinstance(space, (list, tuple)):
-            array = np.array(space)
+        if isinstance(space, list):
+            if isinstance(space[0], int):
+                try:
+                    if all(i == j for i, j in zip(
+                            space,
+                            range(space[0], space[-1] + 1, space[1] -
+                                  space[0]))):
+                        return range(space[0], space[-1] + 1,
+                                     space[1] - space[0])
+                except:
+                    return space
+            elif isinstance(space[0], (float, complex, np.ndarray)):
+                array = np.array(space)
+            else:
+                return space
         elif isinstance(space, np.ndarray):
             array = space
+        else:
+            return space
         try:
             a = np.linspace(array[0], array[-1], len(array), dtype=array.dtype)
             if np.allclose(a, array):

qulab/scan/utils.py

@@ -1,6 +1,11 @@
 import ast
 import asyncio
 import inspect
+import platform
+import re
+import subprocess
+import sys
+import uuid
 import warnings
 from typing import Any, Callable
 
@@ -169,3 +174,56 @@ async def call_function(func: Callable | Expression, variables: dict[str,
     if inspect.isawaitable(ret):
         ret = await ret
     return ret
+
+
+def yapf_reformat(cell_text):
+    try:
+        import isort
+        import yapf.yapflib.yapf_api
+
+        fname = f"f{uuid.uuid1().hex}"
+
+        def wrap(source):
+            lines = [f"async def {fname}():"]
+            for line in source.split('\n'):
+                lines.append("    " + line)
+            return '\n'.join(lines)
+
+        def unwrap(source):
+            lines = []
+            for line in source.split('\n'):
+                if line.startswith(f"async def {fname}():"):
+                    continue
+                lines.append(line[4:])
+            return '\n'.join(lines)
+
+        cell_text = re.sub('^%', '#%#', cell_text, flags=re.M)
+        reformated_text = unwrap(
+            yapf.yapflib.yapf_api.FormatCode(wrap(isort.code(cell_text)))[0])
+        return re.sub('^#%#', '%', reformated_text, flags=re.M)
+    except:
+        return cell_text
+
+
+def get_installed_packages():
+    result = subprocess.run([sys.executable, '-m', 'pip', 'freeze'],
+                            stdout=subprocess.PIPE,
+                            text=True)
+
+    lines = result.stdout.split('\n')
+    packages = []
+    for line in lines:
+        if line:
+            packages.append(line)
+    return packages
+
+
+def get_system_info():
+    info = {
+        'OS': platform.uname()._asdict(),
+        'Python': sys.version,
+        'PythonExecutable': sys.executable,
+        'PythonPath': sys.path,
+        'packages': get_installed_packages()
+    }
+    return info

qulab/version.py

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