QuLab 2.9.10__tar.gz → 2.10.1__tar.gz

{qulab-2.9.10 → qulab-2.10.1}/PKG-INFO

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

{qulab-2.9.10 → qulab-2.10.1}/QuLab.egg-info/PKG-INFO

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

{qulab-2.9.10 → qulab-2.10.1}/QuLab.egg-info/SOURCES.txt

@@ -18,6 +18,7 @@ qulab/version.py
 qulab/cli/__init__.py
 qulab/cli/commands.py
 qulab/cli/config.py
+qulab/cli/decorators.py
 qulab/executor/__init__.py
 qulab/executor/analyze.py
 qulab/executor/cli.py
@@ -109,5 +110,6 @@ qulab/visualization/qdat.py
 qulab/visualization/rot3d.py
 qulab/visualization/widgets.py
 src/qulab.h
+tests/test_expression.py
 tests/test_kad.py
 tests/test_scan.py

{qulab-2.9.10 → qulab-2.10.1}/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-2.10.1/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-2.9.10 → qulab-2.10.1}/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-2.9.10 → qulab-2.10.1}/qulab/executor/load.py

@@ -135,10 +135,14 @@ def verify_dependence_key(workflow: str | tuple[str, dict[str, Any]]
     if not isinstance(workflow, tuple) or len(workflow) not in [2, 3]:
         raise ValueError(f"Invalid workflow: {workflow}")
 
-    if len(workflow) == 2:
+    if len(workflow) == 2 and isinstance(workflow[1], str):
         file_name, mapping = workflow
         if not Path(file_name).exists():
             raise FileNotFoundError(f"File not found: {file_name}")
+    elif len(workflow) == 2 and isinstance(workflow[1], dict):
+        template_path, mapping = workflow
+        if not (Path(base_path) / template_path).exists():
+            raise FileNotFoundError(f"File not found: {template_path}")
     elif len(workflow) == 3:
         template_path, target_path, mapping = workflow
         if not (Path(base_path) / template_path).exists():

{qulab-2.9.10 → qulab-2.10.1}/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-2.9.10 → qulab-2.10.1}/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