QuLab 2.9.9__cp310-cp310-macosx_10_9_universal2.whl → 2.10.0__cp310-cp310-macosx_10_9_universal2.whl

qulab/cli/config.py

@@ -11,7 +11,10 @@ CONFIG_PATH = os.path.expanduser("~/.qulab.ini")
 ENV_PREFIX = "QULAB_"
 
 
-def _get_config_value(option_name, type_cast=str, command_name=None):
+def _get_config_value(option_name,
+                      type_cast=str,
+                      command_name=None,
+                      default=None):
     """支持命令专属配置的优先级获取"""
     # 构造环境变量名
     if command_name:
@@ -47,34 +50,90 @@ def _get_config_value(option_name, type_cast=str, command_name=None):
                 return os.path.expanduser(config_value)
             return type_cast(config_value)
 
-    return None  # 交给 Click 处理默认值
-
-
-def get_config_value(option_name, type_cast=str, command_name=None):
-    value = _get_config_value(option_name, type_cast, command_name)
+    return default  # 交给 Click 处理默认值
+
+
+def get_config_value(option_name,
+                     type_cast=str,
+                     command_name=None,
+                     default=None):
+    """
+    获取配置值，支持命令专属配置的优先级获取
+
+    优先级：
+    1. 命令行参数
+    2. 配置文件专属配置
+    3. 配置文件公共配置
+    4. 环境变量专属配置
+    5. 环境变量公共配置
+    6. 默认值
+    7. Click 处理默认值
+    8. None
+
+    Parameters
+    ----------
+    option_name : str
+        配置项名称
+    type_cast : type
+        转换类型
+    command_name : str
+        命令名称
+        如果为 None，则不使用命令专属配置
+    default : any
+        默认值
+        如果为 None，则不使用默认值
+    
+    Returns
+    -------
+    any
+        配置值
+        如果没有找到配置值，则返回 None
+    """
+    value = _get_config_value(option_name,
+                              type_cast,
+                              command_name,
+                              default=default)
     if value is None and command_name is not None:
-        return _get_config_value(option_name, type_cast)
+        return _get_config_value(option_name, type_cast, default=default)
     return value
 
 
-def log_options(func):
-    """通用配置装饰器（所有命令共用）"""
+def log_options(func=None, command_name=None):
+    """通用配置装饰器（所有命令共用)
+    
+    添加 --debug, --log, --debug-log, --quiet 选项
+    1. --debug: 是否开启调试模式
+    2. --log: 日志文件路径
+    3. --debug-log: 调试日志文件路径
+    4. --quiet: 是否静默输出
+    """
+
+    if isinstance(func, str):
+        return functools.partial(log_options, command_name=func)
+    if func is None:
+        return functools.partial(log_options, command_name=command_name)
 
     @click.option("--debug",
                   is_flag=True,
-                  default=get_config_value("debug", bool),
+                  default=get_config_value("debug",
+                                           bool,
+                                           command_name=command_name),
                   help=f"Enable debug mode")
     @click.option("--log",
                   type=click.Path(),
-                  default=lambda: get_config_value("log", Path),
+                  default=lambda: get_config_value(
+                      "log", Path, command_name=command_name),
                   help=f"Log file path")
     @click.option("--debug-log",
                   type=click.Path(),
-                  default=lambda: get_config_value("debug_log", Path),
+                  default=lambda: get_config_value(
+                      "debug_log", Path, command_name=command_name),
                   help=f"Debug log file path")
     @click.option("--quiet",
                   is_flag=True,
-                  default=get_config_value("quiet", bool),
+                  default=get_config_value("quiet",
+                                           bool,
+                                           command_name=command_name),
                   help=f"Disable log output")
     @functools.wraps(func)
     def wrapper(*args, **kwargs):

qulab/cli/decorators.py

@@ -0,0 +1,28 @@
+import asyncio
+import functools
+import inspect
+
+
+def async_command(func=None):
+    """
+    Decorator to mark a function as an asynchronous command.
+    """
+    if func is None:
+        return async_command
+
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        return run(func, *args, **kwargs)
+
+    return wrapper
+
+
+def run(main, *args, **kwds):
+    if inspect.iscoroutinefunction(main):
+        try:
+            import uvloop
+            uvloop.run(main(*args, **kwds))
+        except ImportError:
+            asyncio.run(main(*args, **kwds))
+    else:
+        main(*args, **kwds)

qulab/executor/cli.py

@@ -9,6 +9,7 @@ import click
 from loguru import logger
 
 from ..cli.config import get_config_value, log_options
+from ..cli.decorators import async_command
 from .load import (WorkflowType, find_unreferenced_workflows, get_entries,
                    load_workflow, make_graph)
 from .schedule import CalibrationFailedError
@@ -165,7 +166,8 @@ def get(key, api):
 @click.option('--freeze', is_flag=True, help='Freeze the config table.')
 @log_options
 @command_option('run')
-def run(workflow, code, data, api, plot, no_dependents, retry, freeze):
+@async_command
+async def run(workflow, code, data, api, plot, no_dependents, retry, freeze):
     """
     Run a workflow.
 
@@ -204,29 +206,33 @@ def run(workflow, code, data, api, plot, no_dependents, retry, freeze):
             if no_dependents:
                 if hasattr(wf, 'entries'):
                     for entry in get_entries(wf, code):
-                        run_workflow(entry,
-                                     code,
-                                     data,
-                                     plot=plot,
-                                     freeze=freeze)
+                        await run_workflow(entry,
+                                           code,
+                                           data,
+                                           plot=plot,
+                                           freeze=freeze)
                 else:
-                    run_workflow(wf, code, data, plot=plot, freeze=freeze)
+                    await run_workflow(wf,
+                                       code,
+                                       data,
+                                       plot=plot,
+                                       freeze=freeze)
             else:
                 if hasattr(wf, 'entries'):
                     for entry in get_entries(wf, code):
-                        maintain_workflow(entry,
-                                          code,
-                                          data,
-                                          run=True,
-                                          plot=plot,
-                                          freeze=freeze)
+                        await maintain_workflow(entry,
+                                                code,
+                                                data,
+                                                run=True,
+                                                plot=plot,
+                                                freeze=freeze)
                 else:
-                    maintain_workflow(wf,
-                                      code,
-                                      data,
-                                      run=True,
-                                      plot=plot,
-                                      freeze=freeze)
+                    await maintain_workflow(wf,
+                                            code,
+                                            data,
+                                            run=True,
+                                            plot=plot,
+                                            freeze=freeze)
             break
         except CalibrationFailedError as e:
             if i == retry - 1:
@@ -241,7 +247,8 @@ def run(workflow, code, data, api, plot, no_dependents, retry, freeze):
 @click.option('--plot', '-p', is_flag=True, help='Plot the report.')
 @log_options
 @command_option('maintain')
-def maintain(workflow, code, data, api, retry, plot):
+@async_command
+async def maintain(workflow, code, data, api, retry, plot):
     """
     Maintain a workflow.
 
@@ -275,19 +282,19 @@ def maintain(workflow, code, data, api, retry, plot):
         try:
             if hasattr(wf, 'entries'):
                 for entry in get_entries(wf, code):
-                    maintain_workflow(entry,
-                                      code,
-                                      data,
-                                      run=False,
-                                      plot=plot,
-                                      freeze=False)
+                    await maintain_workflow(entry,
+                                            code,
+                                            data,
+                                            run=False,
+                                            plot=plot,
+                                            freeze=False)
             else:
-                maintain_workflow(wf,
-                                  code,
-                                  data,
-                                  run=False,
-                                  plot=plot,
-                                  freeze=False)
+                await maintain_workflow(wf,
+                                        code,
+                                        data,
+                                        run=False,
+                                        plot=plot,
+                                        freeze=False)
             break
         except CalibrationFailedError as e:
             if i == retry - 1:
@@ -301,7 +308,8 @@ def maintain(workflow, code, data, api, retry, plot):
 @click.option('--plot', '-p', is_flag=True, help='Plot the report.')
 @log_options
 @command_option('reproduce')
-def reproduce(report_id, code, data, api, plot):
+@async_command
+async def reproduce(report_id, code, data, api, plot):
     """
     Reproduce a report.
 
@@ -335,6 +343,6 @@ def reproduce(report_id, code, data, api, plot):
     cfg = transform.export_config()
     transform.clear_config()
     transform.update_config(r.config)
-    run_workflow(wf, code, data, plot=plot, freeze=True)
+    await run_workflow(wf, code, data, plot=plot, freeze=True)
     transform.clear_config()
     transform.update_config(cfg)

qulab/executor/load.py

@@ -1,7 +1,7 @@
-import graphlib
+import atexit
 import inspect
 import pickle
-import sys
+import tempfile
 import warnings
 from importlib.util import module_from_spec, spec_from_file_location
 from pathlib import Path
@@ -333,17 +333,18 @@ def load_workflow_from_file(file_name: str,
 def load_workflow_from_source_code(workflow_id: str,
                                    source_code: str,
                                    package='workflows') -> WorkflowType:
-    path = Path(workflow_id)
-    module_name = f"{package}.{'.'.join([*path.parts[:-1], path.stem])}"
+    workflow_path = Path(workflow_id)
+    module_name = f"{package}.{'.'.join([*workflow_path.parts[:-1], workflow_path.stem])}"
+
+    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.py').name
+    with open(temp_file, 'w') as f:
+        f.write(source_code)
+
+    atexit.register(lambda f=temp_file: Path(f).unlink(missing_ok=True))
 
-    # 创建一个新的模块对象
-    module = ModuleType(module_name)
-    # 将模块注册到sys.modules中
-    sys.modules[module_name] = module
-    # 将源代码编译成字节码
-    code = compile(source_code, '<string>', 'exec')
-    # 在模块的命名空间中执行字节码
-    exec(code, module.__dict__)
+    spec = spec_from_file_location(module_name, temp_file)
+    module = module_from_spec(spec)
+    spec.loader.exec_module(module)
 
     module.__source__ = source_code
     module.__mtime__ = 0

qulab/executor/schedule.py

@@ -127,18 +127,25 @@ def check_state(workflow: WorkflowType, code_path: str | Path,
 
 
 @logger.catch()
-def call_plot(node: WorkflowType, report: Report, check=False):
+async def call_plot(node: WorkflowType, report: Report, check=False):
     if hasattr(node, 'plot') and callable(node.plot):
-        node.plot(report)
+        if inspect.iscoroutinefunction(node.plot):
+            await node.plot(report, check=check)
+        else:
+            node.plot(report)
 
 
-def call_check(workflow: WorkflowType, session_id: str, state_path: Path):
+async def call_check(workflow: WorkflowType, session_id: str,
+                     state_path: Path):
     report = get_cache(session_id, (workflow.__workflow_id__, 'check'))
     if report is not None:
         logger.debug(f'Cache hit for "{workflow.__workflow_id__}:check"')
         return report
 
-    data = workflow.check()
+    if inspect.iscoroutinefunction(workflow.check):
+        data = await workflow.check()
+    else:
+        data = workflow.check()
     if not is_pickleable(data):
         raise TypeError(
             f'"{workflow.__workflow_id__}" : "check" return not pickleable data'
@@ -159,13 +166,17 @@ def call_check(workflow: WorkflowType, session_id: str, state_path: Path):
     return report
 
 
-def call_calibrate(workflow: WorkflowType, session_id: str, state_path: Path):
+async def call_calibrate(workflow: WorkflowType, session_id: str,
+                         state_path: Path):
     report = get_cache(session_id, (workflow.__workflow_id__, 'calibrate'))
     if report is not None:
         logger.debug(f'Cache hit for "{workflow.__workflow_id__}:calibrate"')
         return report
 
-    data = workflow.calibrate()
+    if inspect.iscoroutinefunction(workflow.calibrate):
+        data = await workflow.calibrate()
+    else:
+        data = workflow.calibrate()
     if not is_pickleable(data):
         raise TypeError(
             f'"{workflow.__workflow_id__}" : "calibrate" return not pickleable data'
@@ -186,12 +197,15 @@ def call_calibrate(workflow: WorkflowType, session_id: str, state_path: Path):
     return report
 
 
-def call_check_analyzer(node: WorkflowType,
-                        report: Report,
-                        history: Report | None,
-                        state_path: Path,
-                        plot=False) -> Report:
-    report = node.check_analyze(report, history=history)
+async def call_check_analyzer(node: WorkflowType,
+                              report: Report,
+                              history: Report | None,
+                              state_path: Path,
+                              plot=False) -> Report:
+    if inspect.iscoroutinefunction(node.check_analyze):
+        report = await node.check_analyze(report, history=history)
+    else:
+        report = node.check_analyze(report, history=history)
     veryfy_analyzed_report(report, node.__workflow_id__, "check_analyze")
     report.fully_calibrated = False
     if report.in_spec:
@@ -211,26 +225,29 @@ def call_check_analyzer(node: WorkflowType,
     return report
 
 
-def call_analyzer(node: WorkflowType,
-                  report: Report,
-                  history: Report | None,
-                  state_path: Path,
-                  plot=False) -> Report:
-
-    report = node.analyze(report, history=history)
+async def call_analyzer(node: WorkflowType,
+                        report: Report,
+                        history: Report | None,
+                        state_path: Path,
+                        plot=False) -> Report:
+    if inspect.iscoroutinefunction(node.analyze):
+        report = await node.analyze(report, history=history)
+    else:
+        report = node.analyze(report, history=history)
     veryfy_analyzed_report(report, node.__workflow_id__, "analyze")
     if hasattr(node, 'oracle') and callable(node.oracle):
         logger.debug(
             f'"{node.__workflow_id__}" has oracle method, calling ...')
-        report = call_oracle(node, report, history)
+        report = await call_oracle(node, report, history)
     report.fully_calibrated = True
     save_report(node.__workflow_id__, report, state_path, overwrite=True)
     if plot:
-        call_plot(node, report)
+        await call_plot(node, report)
     return report
 
 
-def call_oracle(node: WorkflowType, report: Report, history: Report | None):
+async def call_oracle(node: WorkflowType, report: Report,
+                      history: Report | None):
     sig = inspect.signature(node.oracle)
     try:
         if 'history' in sig.parameters and 'system_state' in sig.parameters:
@@ -244,6 +261,8 @@ def call_oracle(node: WorkflowType, report: Report, history: Report | None):
                                  system_state=get_heads(report.base_path))
         else:
             report = node.oracle(report)
+        if inspect.isawaitable(report):
+            report = await report
     except Exception as e:
         logger.exception(e)
         report.oracle = {}
@@ -259,8 +278,8 @@ def call_oracle(node: WorkflowType, report: Report, history: Report | None):
     return report
 
 
-def check_data(workflow: WorkflowType, state_path: str | Path, plot: bool,
-               session_id: str) -> Report:
+async def check_data(workflow: WorkflowType, state_path: str | Path,
+                     plot: bool, session_id: str) -> Report:
     """
     check data answers two questions:
     Is the parameter associated with this cal in spec,
@@ -299,52 +318,56 @@ def check_data(workflow: WorkflowType, state_path: str | Path, plot: bool,
         logger.debug(
             f'Checking "{workflow.__workflow_id__}" with "check" method ...')
 
-        report = call_check(workflow, session_id, state_path)
+        report = await call_check(workflow, session_id, state_path)
 
         logger.debug(f'Checked "{workflow.__workflow_id__}" !')
-        report = call_check_analyzer(workflow,
-                                     report,
-                                     history,
-                                     state_path,
-                                     plot=plot)
+        report = await call_check_analyzer(workflow,
+                                           report,
+                                           history,
+                                           state_path,
+                                           plot=plot)
     else:
         logger.debug(
             f'Checking "{workflow.__workflow_id__}" with "calibrate" method ...'
         )
 
-        report = call_calibrate(workflow, session_id, state_path)
+        report = await call_calibrate(workflow, session_id, state_path)
 
         logger.debug(f'Calibrated "{workflow.__workflow_id__}" !')
-        report = call_analyzer(workflow,
-                               report,
-                               history,
-                               state_path,
-                               plot=plot)
+        report = await call_analyzer(workflow,
+                                     report,
+                                     history,
+                                     state_path,
+                                     plot=plot)
     return report
 
 
-def calibrate(workflow: WorkflowType, state_path: str | Path, plot: bool,
-              session_id: str) -> Report:
+async def calibrate(workflow: WorkflowType, state_path: str | Path, plot: bool,
+                    session_id: str) -> Report:
     history = find_report(workflow.__workflow_id__, state_path)
 
     logger.debug(f'Calibrating "{workflow.__workflow_id__}" ...')
 
-    report = call_calibrate(workflow, session_id, state_path)
+    report = await call_calibrate(workflow, session_id, state_path)
 
     logger.debug(f'Calibrated "{workflow.__workflow_id__}" !')
 
-    report = call_analyzer(workflow, report, history, state_path, plot=plot)
+    report = await call_analyzer(workflow,
+                                 report,
+                                 history,
+                                 state_path,
+                                 plot=plot)
     return report
 
 
-def diagnose(workflow: WorkflowType, code_path: str | Path,
-             state_path: str | Path, plot: bool, session_id: str):
+async def diagnose(workflow: WorkflowType, code_path: str | Path,
+                   state_path: str | Path, plot: bool, session_id: str):
     '''
     Returns: True if node or dependent recalibrated.
     '''
     logger.debug(f'diagnose "{workflow.__workflow_id__}"')
     # check_data
-    report = check_data(workflow, state_path, plot, session_id)
+    report = await check_data(workflow, state_path, plot, session_id)
     # in spec case
     if report.in_spec:
         logger.debug(
@@ -357,7 +380,7 @@ def diagnose(workflow: WorkflowType, code_path: str | Path,
         logger.debug(
             f'"{workflow.__workflow_id__}": Bad data, diagnosing dependents')
         recalibrated = [
-            diagnose(n, code_path, state_path, plot, session_id)
+            await diagnose(n, code_path, state_path, plot, session_id)
             for n in get_dependents(workflow, code_path)
         ]
     if not any(recalibrated):
@@ -386,7 +409,7 @@ def diagnose(workflow: WorkflowType, code_path: str | Path,
     else:
         logger.error(f'Never reach: recalibrate "{workflow.__workflow_id__}"')
 
-    report = calibrate(workflow, state_path, plot, session_id)
+    report = await calibrate(workflow, state_path, plot, session_id)
     if report.bad_data or not report.in_spec:
         obey_the_oracle(report, state_path)
         raise CalibrationFailedError(
@@ -398,13 +421,13 @@ def diagnose(workflow: WorkflowType, code_path: str | Path,
 
 
 @logger.catch(reraise=True)
-def maintain(workflow: WorkflowType,
-             code_path: str | Path,
-             state_path: str | Path,
-             session_id: str | None = None,
-             run: bool = False,
-             plot: bool = False,
-             freeze: bool = False):
+async def maintain(workflow: WorkflowType,
+                   code_path: str | Path,
+                   state_path: str | Path,
+                   session_id: str | None = None,
+                   run: bool = False,
+                   plot: bool = False,
+                   freeze: bool = False):
     if session_id is None:
         session_id = uuid.uuid4().hex
     logger.debug(f'run "{workflow.__workflow_id__}"'
@@ -414,13 +437,13 @@ def maintain(workflow: WorkflowType,
         logger.debug(
             f'maintain "{n.__workflow_id__}" because it is depended by "{workflow.__workflow_id__}"'
         )
-        maintain(n,
-                 code_path,
-                 state_path,
-                 session_id,
-                 run=False,
-                 plot=plot,
-                 freeze=freeze)
+        await maintain(n,
+                       code_path,
+                       state_path,
+                       session_id,
+                       run=False,
+                       plot=plot,
+                       freeze=freeze)
     else:
         logger.debug(
             f'"{workflow.__workflow_id__}": All dependents maintained')
@@ -430,7 +453,7 @@ def maintain(workflow: WorkflowType,
             f'"{workflow.__workflow_id__}": In spec, no need to maintain')
         return
     # check_data
-    report = check_data(workflow, state_path, plot, session_id)
+    report = await check_data(workflow, state_path, plot, session_id)
     if report.in_spec:
         if not run:
             logger.debug(
@@ -443,13 +466,13 @@ def maintain(workflow: WorkflowType,
             logger.debug(
                 f'diagnose "{n.__workflow_id__}" because of "{workflow.__workflow_id__}" bad data'
             )
-            diagnose(n, code_path, state_path, plot, session_id)
+            await diagnose(n, code_path, state_path, plot, session_id)
         else:
             logger.debug(
                 f'"{workflow.__workflow_id__}": All dependents diagnosed')
     # calibrate
     logger.debug(f'recalibrate "{workflow.__workflow_id__}"')
-    report = calibrate(workflow, state_path, plot, session_id)
+    report = await calibrate(workflow, state_path, plot, session_id)
     if report.bad_data or not report.in_spec:
         if not freeze:
             obey_the_oracle(report, state_path)
@@ -465,14 +488,14 @@ def maintain(workflow: WorkflowType,
 
 
 @logger.catch(reraise=True)
-def run(workflow: WorkflowType,
-        code_path: str | Path,
-        state_path: str | Path,
-        plot: bool = False,
-        freeze: bool = False):
+async def run(workflow: WorkflowType,
+              code_path: str | Path,
+              state_path: str | Path,
+              plot: bool = False,
+              freeze: bool = False):
     session_id = uuid.uuid4().hex
     logger.debug(f'run "{workflow.__workflow_id__}" without dependences.')
-    report = calibrate(workflow, state_path, plot, session_id=session_id)
+    report = await calibrate(workflow, state_path, plot, session_id=session_id)
     if report.bad_data or not report.in_spec:
         if not freeze:
             obey_the_oracle(report, state_path)

qulab/executor/utils.py

@@ -1,3 +1,4 @@
+import inspect
 from pathlib import Path
 
 from ..cli.config import get_config_value
@@ -155,7 +156,7 @@ def oracle(report: Report,
 """
 
 
-def debug_analyze(
+async def debug_analyze(
         report_index: int,
         code_path: str | Path = get_config_value('code', Path),
         data_path: str | Path = get_config_value('data', Path),
@@ -170,7 +171,8 @@ def debug_analyze(
     if wf is None:
         raise ValueError(f'Invalid workflow: {workflow}')
     if hasattr(wf, '__QULAB_TEMPLATE__'):
-        template_mtime = (Path(code_path) / wf.__QULAB_TEMPLATE__).stat().st_mtime
+        template_mtime = (Path(code_path) /
+                          wf.__QULAB_TEMPLATE__).stat().st_mtime
         if template_mtime > wf.__mtime__:
             for k in dir(wf):
                 if k.startswith('__VAR_') and len(k) == len('__VAR_17fb4dde'):
@@ -182,6 +184,11 @@ def debug_analyze(
                                code_path)
 
     report = wf.analyze(report, report.previous)
+    if inspect.isawaitable(report):
+        report = await report
     if hasattr(wf, 'plot'):
-        wf.plot(report)
+        if inspect.iscoroutinefunction(wf.plot):
+            await wf.plot(report)
+        else:
+            wf.plot(report)
     return report

qulab/scan/expression.py

@@ -4,42 +4,154 @@ import operator
 
 import numpy as np
 from pyparsing import (CaselessKeyword, Combine, Forward, Group, Keyword,
-                       Literal, Optional, ParserElement, Suppress, Word,
-                       alphanums, alphas, delimitedList, nums, oneOf, opAssoc,
-                       pyparsing_common, restOfLine, srange, stringEnd,
-                       stringStart)
+                       Literal, Optional, ParserElement, ParseResults,
+                       Suppress, Word, alphanums, alphas, delimitedList,
+                       infixNotation, nums, oneOf, opAssoc, pyparsing_common,
+                       restOfLine, srange, stringEnd, stringStart)
 from scipy import special
 
-LPAREN, RPAREN, LBRACK, RBRACK, LBRACE, RBRACE, DOT, TILDE, BANG, PLUS, MINUS = map(
-    Suppress, "()[]{}.~!+-")
-
-INT = Combine(srange("[1-9]") +
-              Optional(Word(nums))).set_parse_action(lambda t: int(t[0]))
-OCT = Combine("0" + Word("01234567")).set_parse_action(lambda t: int(t[0], 8))
-HEX = Combine("0x" + Word("0123456789abcdefABCDEF")).set_parse_action(
+# 启用 Packrat 优化以提高解析效率
+ParserElement.enablePackrat()
+
+# 定义符号（括号、方括号、花括号、点号等）的 Suppress 版
+LPAREN, RPAREN = map(Suppress, "()")
+LBRACK, RBRACK = map(Suppress, "[]")
+LBRACE, RBRACE = map(Suppress, "{}")
+DOT = Suppress(".")
+COMMA = Suppress(",")
+
+# 数字定义：整数（十进制、八进制、十六进制）和浮点数
+INT = (Combine(Word("123456789", nums))
+       | Literal("0")).setParseAction(lambda t: int(t[0]))
+OCT = Combine("0" + Word("01234567")).setParseAction(lambda t: int(t[0], 8))
+HEX = Combine("0x" + Word("0123456789abcdefABCDEF")).setParseAction(
     lambda t: int(t[0], 16))
-FLOAT = Combine(Word(nums) + DOT + Word(nums)) | \
-        Combine(DOT + Word(nums)) | \
-        Combine(Word(nums) + DOT) | \
-        Combine(Word(nums) + DOT + Word(nums) + CaselessKeyword("e") + Word("+-") + Word(nums)) | \
-        Combine(Word(nums) + DOT + CaselessKeyword("e") + Word("+-") + Word(nums)) | \
-        Combine(DOT + Word(nums) + CaselessKeyword("e") + Word("+-") + Word(nums)) | \
-        Combine(Word(nums) + CaselessKeyword("e") + Word("+-") + Word(nums))
-FLOAT.set_parse_action(lambda t: float(t[0]))
-SYMBOL = Word(alphas, alphanums + "_")
-SYMBOL.set_parse_action(lambda t: Symbol(t[0]))
-
-expr = Forward()
-unary = Forward()
-binary = Forward()
-atom = Forward()
+FLOAT = Combine(
+    Word(nums) + '.' + Word(nums) | '.' + Word(nums) | Word(nums) + '.'
+    | Word(nums) + (Literal('e') | Literal('E')) +
+    Word("+-" + nums)).setParseAction(lambda t: float(t[0]))
+
+
+# 定义标识符，转换为 Symbol 对象（在 Expression 类中已定义）
+def symbol_parse_action(t):
+    return Symbol(t[0])
+
+
+SYMBOL = Word(alphas, alphanums + "_").setParseAction(symbol_parse_action)
+
+#------------------------------------------------------------------------------
+# 定义运算表达式的解析动作转换函数
+
+# 一元运算符映射（注意：此处 ! 使用逻辑非 operator.not_）
+unary_ops = {
+    '+': operator.pos,
+    '-': operator.neg,
+    '~': operator.invert,
+    '!': operator.not_
+}
+
+
+def unary_parse_action(tokens: ParseResults) -> Expression:
+    # tokens 形如：[['-', operand]]
+    op, operand = tokens[0]
+    # operand 已经是 Expression 对象（或常量），构造 UnaryExpression
+    return UnaryExpression(operand, unary_ops[op])
+
+
+# 二元运算符映射
+binary_ops = {
+    '+': operator.add,
+    '-': operator.sub,
+    '*': operator.mul,
+    '/': operator.truediv,
+    '//': operator.floordiv,
+    '%': operator.mod,
+    '**': operator.pow,
+    '@': operator.matmul,
+    '<<': operator.lshift,
+    '>>': operator.rshift,
+    '&': operator.and_,
+    '^': operator.xor,
+    '|': operator.or_,
+    '<': operator.lt,
+    '<=': operator.le,
+    '>': operator.gt,
+    '>=': operator.ge,
+    '==': operator.eq,
+    '!=': operator.ne
+}
+
+
+def binary_parse_action(tokens: ParseResults) -> Expression:
+    # tokens[0] 为形如：[operand1, op, operand2, op, operand3, ...]
+    t = tokens[0]
+    expr = t[0]
+    for i in range(1, len(t), 2):
+        op = t[i]
+        right = t[i + 1]
+        expr = BinaryExpression(expr, right, binary_ops[op])
+    return expr
 
-atom << (INT | OCT | HEX | FLOAT | SYMBOL | (LPAREN + expr + RPAREN) |
-         (LBRACK + expr + RBRACK) | (LBRACE + expr + RBRACE) | (MINUS + atom) |
-         (PLUS + atom) | (TILDE + atom) | (BANG + atom) | (nums + DOT + nums))
 
-unary << (atom | (MINUS + unary) | (PLUS + unary) | (TILDE + unary) |
-          (BANG + unary))
+expr = Forward()
+#------------------------------------------------------------------------------
+# 构造基元表达式：包括数值、标识符、括号内表达式
+atom = (
+    FLOAT | INT | OCT | HEX | SYMBOL |
+    (LPAREN + expr + RPAREN)  # 注意：后面我们将使用递归定义 expr
+)
+
+
+# 为支持函数调用和属性访问，构造后缀表达式：
+# 例如： func(x,y).attr
+def parse_function_call(expr_obj):
+    # 参数列表可能为空，或者用逗号分隔的表达式列表
+    arg_list = Optional(delimitedList(expr), default=[])
+    return LPAREN + Group(arg_list) + RPAREN
+
+
+postfix = Forward()
+# 后缀可以是函数调用，也可以是属性访问
+postfix_operation = ((parse_function_call(atom)
+                      ).setParseAction(lambda t: ('CALL', t[0].asList())) |
+                     (DOT + SYMBOL).setParseAction(lambda t: ('ATTR', t[0])))
+
+
+# 定义 factor：先解析 atom，然后再依次处理后缀操作
+def attach_postfix(tokens: ParseResults) -> Expression:
+    # tokens[0] 为初始的 atom 对象
+    expr_obj = tokens[0]
+    # 遍历后缀操作序列
+    for op, arg in tokens[1:]:
+        if op == 'CALL':
+            # 对于函数调用，arg 是参数列表，调用 __call__ 运算符（由 Expression.__call__ 实现）
+            expr_obj = expr_obj(*arg)
+        elif op == 'ATTR':
+            # 对于属性访问，用 ObjectMethod 构造
+            expr_obj = ObjectMethod(expr_obj, '__getattr__', arg)
+    return expr_obj
+
+
+# 将 atom 与后缀操作连接
+postfix << (atom + Optional(
+    (postfix_operation[...]))).setParseAction(attach_postfix)
+
+#------------------------------------------------------------------------------
+# 现在构造整个表达式解析器，利用 infixNotation 建立运算符优先级
+expr <<= infixNotation(
+    postfix,
+    [
+        (oneOf('! ~ + -'), 1, opAssoc.RIGHT, unary_parse_action),
+        # 指数运算，右结合
+        (Literal("**"), 2, opAssoc.RIGHT, binary_parse_action),
+        (oneOf('* / // % @'), 2, opAssoc.LEFT, binary_parse_action),
+        (oneOf('+ -'), 2, opAssoc.LEFT, binary_parse_action),
+        (oneOf('<< >>'), 2, opAssoc.LEFT, binary_parse_action),
+        (oneOf('&'), 2, opAssoc.LEFT, binary_parse_action),
+        (oneOf('^'), 2, opAssoc.LEFT, binary_parse_action),
+        (oneOf('|'), 2, opAssoc.LEFT, binary_parse_action),
+        (oneOf('< <= > >= == !='), 2, opAssoc.LEFT, binary_parse_action),
+    ])
 
 ConstType = (int, float, complex)
 _empty = object()
@@ -91,7 +203,8 @@ class Env():
         }
 
     def __contains__(self, key):
-        return key in self.consts or key in self.variables or key in self.functions or key in self.refs
+        return (key in self.consts or key in self.variables
+                or key in self.functions or key in self.refs)
 
     def __getitem__(self, key):
         if key in self.consts:
@@ -107,6 +220,8 @@ class Env():
     def __setitem__(self, key, value):
         if key in self.consts:
             raise KeyError(f"Key {key:r} is const")
+        if key in self.functions:
+            raise KeyError(f"Key {key:r} is function")
         elif isinstance(value, Ref):
             self.create_ref(key, value.name)
         elif key in self.refs:
@@ -117,6 +232,8 @@ class Env():
     def __delitem__(self, key):
         if key in self.consts:
             raise KeyError(f"Key {key:r} is const")
+        if key in self.functions:
+            raise KeyError(f"Key {key:r} is function")
         elif key in self.refs:
             del self[self.refs[key]]
         else:
@@ -576,8 +693,14 @@ class ObjectMethod(Expression):
         if isinstance(obj, Expression) or any(
                 isinstance(x, Expression) for x in args):
             return ObjectMethod(obj, self.method, *args)
+        elif self.method == '__getattr__':
+            print(f"getattr {obj} {args}")
+            return getattr(
+                obj, *[a.name if isinstance(a, Symbol) else a for a in args])
         else:
-            return getattr(obj, self.method)(*args)
+            return getattr(obj, self.method)(*[
+                a.value(env) if isinstance(a, Expression) else a for a in args
+            ])
 
     def __repr__(self):
         if self.method == '__call__':
@@ -604,7 +727,11 @@ class Symbol(Expression):
 
     def eval(self, env):
         if self.name in env:
-            return env[self.name]
+            value = env[self.name]
+            if isinstance(value, Expression):
+                return value.eval(env)
+            else:
+                return value
         else:
             return self
 
@@ -644,3 +771,29 @@ sign = Symbol('sign')
 heaviside = Symbol('heaviside')
 erf = Symbol('erf')
 erfc = Symbol('erfc')
+
+
+def calc(exp: str | Expression, **kwargs) -> Expression:
+    """
+    Calculate the expression.
+
+    Parameters
+    ----------
+    exp : str | Expression
+        The expression to be calculated.
+    env : Env, optional
+        The environment to be used for the calculation. Default is _default_env.
+    **kwargs : dict
+        Additional arguments to be passed to the expression.
+
+    Returns
+    -------
+    Expression
+        The calculated expression.
+    """
+    env = Env()
+    for k, v in kwargs.items():
+        env[k] = v
+    if isinstance(exp, str):
+        exp = expr.parseString(exp, parseAll=True)[0]
+    return exp.eval(env)

qulab/scan/server.py

@@ -14,6 +14,7 @@ from loguru import logger
 
 from qulab.sys.rpc.zmq_socket import ZMQContextManager
 
+from ..cli.config import get_config_value, log_options
 from .curd import (create_cell, create_config, create_notebook, get_config,
                    query_record, remove_tags, tag, update_tags)
 from .models import Cell, Notebook
@@ -411,123 +412,36 @@ async def serv(port,
                     last_flush_time = time.time()
 
 
-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:
-                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):
-                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, buffer=1024, interval=60):
+    logger.info('Server starting...')
+    await serv(port, datapath, url, buffer * 1024 * 1024, interval)
 
 
 @click.command()
 @click.option('--port',
-              default=os.getenv('QULAB_RECORD_PORT', 6789),
+              default=get_config_value('port',
+                                       int,
+                                       command_name='server',
+                                       default=6789),
               help='Port of the server.')
-@click.option('--datapath', default=datapath, help='Path of the data.')
+@click.option('--datapath',
+              default=get_config_value('data',
+                                       Path,
+                                       command_name='server',
+                                       default=Path.home() / 'qulab' / 'data'),
+              help='Path of the data.')
 @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.')
-@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):
+@log_options(command_name='server')
+def server(port, datapath, url, buffer, interval):
     try:
         import uvloop
-        uvloop.run(
-            main(port, Path(datapath), url, timeout, buffer, interval, log,
-                 True, debug))
+        uvloop.run(main(port, Path(datapath), url, buffer, interval))
     except ImportError:
-        asyncio.run(
-            main(port, Path(datapath), url, timeout, buffer, interval, log,
-                 True, debug))
+        asyncio.run(main(port, Path(datapath), url, buffer, interval))
 
 
 if __name__ == "__main__":

qulab/version.py

@@ -1 +1 @@
-__version__ = "2.9.9"
+__version__ = "2.10.0"

{qulab-2.9.9.dist-info → qulab-2.10.0.dist-info}/METADATA

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

{qulab-2.9.9.dist-info → qulab-2.10.0.dist-info}/RECORD

@@ -1,22 +1,23 @@
 qulab/__init__.py,sha256=fL8FSMGk4vzTMXLxWgNHpd1fNWau4yujSWjPEPqudos,367
 qulab/__main__.py,sha256=fjaRSL_uUjNIzBGNgjlGswb9TJ2VD5qnkZHW3hItrD4,68
 qulab/dicttree.py,sha256=tRRMpGZYVOLw0TEByE3_2Ss8FdOmzuGL9e1DWbs8qoY,13684
-qulab/fun.cpython-310-darwin.so,sha256=XWLiXx9_kVCfIZTM2Qd4MQICq-dRez6ZBl7nLoNxMLA,126864
+qulab/fun.cpython-310-darwin.so,sha256=63ufLELOb5Qais4CFu5O_kWXOezOpdLOhCi4LBK9MP0,126864
 qulab/typing.py,sha256=vg62sGqxuD9CI5677ejlzAmf2fVdAESZCQjAE_xSxPg,69
 qulab/utils.py,sha256=BdLdlfjpe6m6gSeONYmpAKTTqxDaYHNk4exlz8kZxTg,2982
-qulab/version.py,sha256=gB2GONub0WyICh4-SbXI8ce5oNADu2_gH_-ZqWOveM0,21
+qulab/version.py,sha256=-wrxKlVMUOYQC2baw-827pV-q4STQnQkmi5VCiGpO64,22
 qulab/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/cli/commands.py,sha256=F1LATmSC9lOAdnrOTMK7DRjETCEcOmMsocovWRyjWTc,597
-qulab/cli/config.py,sha256=Ei7eSYnbwPPlluDnm8YmWONYiI4g7WtvlZGQdr1Z6vo,3688
+qulab/cli/config.py,sha256=fWeWHiX-Oxodvfv4g0B-UFisJlYcF1Hv6V1fKib2mOM,5447
+qulab/cli/decorators.py,sha256=66lzX1FtGG3C0qheLOjbKquLitnivXgmWyEG2ywRvKY,598
 qulab/executor/__init__.py,sha256=LosPzOMaljSZY1thy_Fxtbrgq7uubJszMABEB7oM7tU,101
 qulab/executor/analyze.py,sha256=4Hau5LrKUdpweh7W94tcG4ahgxucHOevbM0hm57T7zE,5649
-qulab/executor/cli.py,sha256=xceK6XNLnNpAVtqvs0_wOAuG0sgS9jg1iTFYmxVUMWY,11795
-qulab/executor/load.py,sha256=qI-3b3xvsjZMCthRO3hlzHA0BZI-tH9Y_L0XLBcyWV8,18657
-qulab/executor/schedule.py,sha256=XRimchHYCgnMAOtCvNLjwMv9IkcTAyBAUCHKQs5RBRw,18745
+qulab/executor/cli.py,sha256=JhaOvMfLHOFe8HdQhGeqU3Lj3z0mJXLXJhzIwmAsaso,12251
+qulab/executor/load.py,sha256=6QLlATu2KyGY2nrWLFTVxDE4DwoCXx3WNx72QR_LZB0,18715
+qulab/executor/schedule.py,sha256=PmNRvs41DXKC2teHj5XGblpUEKLrsZpgPqk2K-opA-g,20009
 qulab/executor/storage.py,sha256=8K73KGLAVgchJdtd4rKHXkr1CQOJORWH-Gi57w8IYsw,21081
 qulab/executor/template.py,sha256=_HEtsUQ5_jSujCw8FBDAK1PRTMRCa4iD4DduHIpjo3c,10569
 qulab/executor/transform.py,sha256=rk4CLIKVjGRaFzi5FVSgadUxAKKVLSopEHZCaAzDwDg,3435
-qulab/executor/utils.py,sha256=l_b0y2kMwYKyyXeFtoblPYwKNU-wiFQ9PMo9QlWl9wE,6213
+qulab/executor/utils.py,sha256=S254JDTKVA4Fnu9lslNBos6vEssLWn8zbMjhmLP-Gi8,6434
 qulab/monitor/__init__.py,sha256=nTHelnDpxRS_fl_B38TsN0njgq8eVTEz9IAnN3NbDlM,42
 qulab/monitor/__main__.py,sha256=w3yUcqq195LzSnXTkQcuC1RSFRhy4oQ_PEBmucXguME,97
 qulab/monitor/config.py,sha256=fQ5JcsMApKc1UwANEnIvbDQZl8uYW0tle92SaYtX9lI,744
@@ -29,13 +30,13 @@ 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=ZcwO5SKO95OcDgpUPDHcK5FW_BrJbUzuBk71UG_pqnM,6888
-qulab/scan/expression.py,sha256=Yw2_ynDpKiLeyS5m53lURFtesLkzaF9PIyAWbW-LOr0,20176
+qulab/scan/expression.py,sha256=Mk9-hzmTzDszM0p6J_FlrewzQerOBWhRv5_iFApA768,24978
 qulab/scan/models.py,sha256=JFofv-RH0gpS3--M6izXiQg7iGkS9a_em2DwhS5kTTk,17626
 qulab/scan/optimize.py,sha256=VT9TpuqDkG7FdJJkYy60r5Pfrmjvfu5i36Ru6XvIiTI,2561
 qulab/scan/query.py,sha256=-5uHMhXSyGovK1oy_uUbGVEbRFzaMBkP78ZMNfI3jD0,11809
 qulab/scan/record.py,sha256=yIHPANf6nuBXy8Igf-dMtGJ7wuFTLYlBaaAUc0AzwyU,21280
 qulab/scan/scan.py,sha256=iXvbnXLZvHa4v88MlYiZ_LYubEB7ZfbX7OiFTMhl_1o,39479
-qulab/scan/server.py,sha256=PEtitQeejAD11HYwTs1o1kJwkK7BkN0oLhn2_Pypk9M,20054
+qulab/scan/server.py,sha256=QhUo-TxdTb_PDBd4sDRiI5L1WHmuEOAYEmUiFhjNqc4,16995
 qulab/scan/space.py,sha256=OQLepiNNP5TNYMHXeVFT59lL5n4soPmnMoMy_o9EHt0,6696
 qulab/scan/utils.py,sha256=SzJ_c4cLZJzERZr_CJO1_4juOxjfwCpU2K1mkc1PWGM,6124
 qulab/storage/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -98,9 +99,9 @@ qulab/visualization/plot_seq.py,sha256=UWTS6p9nfX_7B8ehcYo6UnSTUCjkBsNU9jiOeW2ca
 qulab/visualization/qdat.py,sha256=ZeevBYWkzbww4xZnsjHhw7wRorJCBzbG0iEu-XQB4EA,5735
 qulab/visualization/rot3d.py,sha256=lMrEJlRLwYe6NMBlGkKYpp_V9CTipOAuDy6QW_cQK00,734
 qulab/visualization/widgets.py,sha256=6KkiTyQ8J-ei70LbPQZAK35wjktY47w2IveOa682ftA,3180
-qulab-2.9.9.dist-info/licenses/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
-qulab-2.9.9.dist-info/METADATA,sha256=YNn0O6ThCfze52902y9RPVsTFtwpoVUpxzKjzqcrZmE,3752
-qulab-2.9.9.dist-info/WHEEL,sha256=qnIvK8L8kOW9FTrzifubcmNsZckgNfGDNKzGG7FMEdE,114
-qulab-2.9.9.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
-qulab-2.9.9.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-qulab-2.9.9.dist-info/RECORD,,
+qulab-2.10.0.dist-info/licenses/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
+qulab-2.10.0.dist-info/METADATA,sha256=zgYXM6nfKcUtCQlhiOXvYpUAmrrQko9kO_7syyfjkCo,3753
+qulab-2.10.0.dist-info/WHEEL,sha256=qnIvK8L8kOW9FTrzifubcmNsZckgNfGDNKzGG7FMEdE,114
+qulab-2.10.0.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
+qulab-2.10.0.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+qulab-2.10.0.dist-info/RECORD,,