QuLab 2.4.10__cp310-cp310-macosx_10_9_universal2.whl → 2.4.12__cp310-cp310-macosx_10_9_universal2.whl

{QuLab-2.4.10.dist-info → QuLab-2.4.12.dist-info}/METADATA

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

{QuLab-2.4.10.dist-info → QuLab-2.4.12.dist-info}/RECORD

@@ -1,12 +1,12 @@
 qulab/__init__.py,sha256=P-Mx2p4TVmL91SoxoeXcj8Qm0x4xUf5Q_FLk0Yc_gIQ,138
-qulab/__main__.py,sha256=V5jIyfuCSi5dI6jvqgH_BpXG0URd6bgneDdVCM1dGSA,545
+qulab/__main__.py,sha256=ThCRooT22_qpwFtbAvVOyHzpBCuGlfDVkXBXvApzgps,597
 qulab/dicttree.py,sha256=tRRMpGZYVOLw0TEByE3_2Ss8FdOmzuGL9e1DWbs8qoY,13684
-qulab/fun.cpython-310-darwin.so,sha256=CZ-gpDm1wuWs_uC5s63khBfYBifKhv8YLI4eQTU0psk,126864
-qulab/version.py,sha256=xpqAldAat_EPvLePX9Bp7bPX0gGKeKjd9kZbsEQVax4,22
+qulab/fun.cpython-310-darwin.so,sha256=l2j8u_hDaQVbFSXjRKFyZxjCsOib1ynJsQdSGXucfj4,126864
+qulab/version.py,sha256=3Ac_4-IUz5KK-UOcxuXzEVTZr4p9bV93jrLgO3Au_zA,22
 qulab/executor/__init__.py,sha256=LosPzOMaljSZY1thy_Fxtbrgq7uubJszMABEB7oM7tU,101
-qulab/executor/__main__.py,sha256=MMkkqpCH-Upwb1gBfvaN2ZuehXkJIMJGa1amYXEjn-Q,4017
-qulab/executor/load.py,sha256=pxq8oFaJLJOT21ue9q-BNlFeJZcjxmGNN0Cz_TColxA,6211
-qulab/executor/schedule.py,sha256=edPjE9U6_WQisSiOCcqov4DVbBVKTPWrBFwcy0ReC2s,10213
+qulab/executor/__main__.py,sha256=qgZcdmx1wBZInHf6ionpuuZytIJnaDje9WRv-a8o2OM,5870
+qulab/executor/load.py,sha256=GSRrP2UXOmTgg5VDTmZy_y4xXk91H3Sd5SEX-tOEBqY,8689
+qulab/executor/schedule.py,sha256=UOace0Gpt9gR0xe1BoNSUfeHxZynaUS0BFHZhmfnB30,11849
 qulab/executor/storage.py,sha256=M66Q5_Uc5MMfc_QAuuaaexwAz7wxBPMkeleB5nRpQmI,4621
 qulab/executor/transform.py,sha256=inaOn6eqCs22ZZ0xAQl8s8YCoEACaXSwFNNu7jqdwAk,2148
 qulab/executor/utils.py,sha256=n3uCSKh-qdDFFeNvOpj7_es2_B4AaC-ASAlV9gPmSO0,3086
@@ -89,9 +89,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.4.10.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
-QuLab-2.4.10.dist-info/METADATA,sha256=IBb9rgsBSQRdKLTgU6xTYP1nFSk_gFo-jrKTEZ9MYps,3699
-QuLab-2.4.10.dist-info/WHEEL,sha256=Yd3eJSBM2hj8W-ouaiMfFUwQYAS-D6P73Ob9yN5MZd0,114
-QuLab-2.4.10.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
-QuLab-2.4.10.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-QuLab-2.4.10.dist-info/RECORD,,
+QuLab-2.4.12.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
+QuLab-2.4.12.dist-info/METADATA,sha256=OdTgtOdriEitEyphmV6lZTskqK97GLmDGp7hkAYQGgo,3699
+QuLab-2.4.12.dist-info/WHEEL,sha256=Yd3eJSBM2hj8W-ouaiMfFUwQYAS-D6P73Ob9yN5MZd0,114
+QuLab-2.4.12.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
+QuLab-2.4.12.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+QuLab-2.4.12.dist-info/RECORD,,

qulab/__main__.py

@@ -1,6 +1,6 @@
 import click
 
-from .executor.__main__ import create, maintain, run
+from .executor.__main__ import create, get, maintain, run, set
 from .monitor.__main__ import main as monitor
 from .scan.server import server
 from .sys.net.cli import dht
@@ -25,6 +25,8 @@ cli.add_command(server)
 cli.add_command(maintain)
 cli.add_command(run)
 cli.add_command(create)
+cli.add_command(set)
+cli.add_command(get)
 
 if __name__ == '__main__':
     cli()

qulab/executor/__main__.py

@@ -1,25 +1,50 @@
 import functools
 import importlib
-import sys, os
+import os
+import sys
 from pathlib import Path
 
 import click
 from loguru import logger
 
-from .load import find_unreferenced_workflows
+from .load import find_unreferenced_workflows, load_workflow
 from .schedule import maintain as maintain_workflow
 from .schedule import run as run_workflow
 from .transform import set_config_api
 from .utils import workflow_template
 
 
+def load_config():
+    import yaml
+
+    config_paths = [
+        Path.home() / ".myapp/config.yaml",  # 用户主目录
+        Path("config.yaml")  # 当前目录
+    ]
+    for path in config_paths:
+        if path.exists():
+            with open(path) as f:
+                return yaml.safe_load(f)
+    return {"defaults": {"log": "default.log", "debug": False}}
+
+
+def get_config_value(option_name):
+    # 1. 尝试从环境变量读取
+    env_value = os.environ.get(f"MYAPP_{option_name.upper()}")
+    if env_value:
+        return env_value
+
+    # 2. 尝试从配置文件读取
+    config = load_config()
+    return config["defaults"].get(option_name)
+
+
 def log_options(func):
 
     @click.option("--debug", is_flag=True, help="Enable debug mode.")
     @click.option("--log", type=str, help="Log file path.")
     @functools.wraps(func)  # 保持函数元信息
     def wrapper(*args, log=None, debug=False, **kwargs):
-        print(f"{func} {log=}, {debug=}")
         if log is None and not debug:
             logger.remove()
             logger.add(sys.stderr, level='INFO')
@@ -67,6 +92,39 @@ def create(workflow, code):
     click.echo(f'{workflow} created')
 
 
+@click.command()
+@click.argument('key')
+@click.argument('value', type=str)
+@click.option('--api', '-a', default=None, help='The modlule name of the api.')
+def set(key, value, api):
+    """
+    Set a config.
+    """
+    from . import transform
+    if api is not None:
+        api = importlib.import_module(api)
+        set_config_api(api.query_config, api.update_config)
+    try:
+        value = eval(value)
+    except:
+        pass
+    transform.update_config({key: value})
+
+
+@click.command()
+@click.argument('key')
+@click.option('--api', '-a', default=None, help='The modlule name of the api.')
+def get(key, api):
+    """
+    Get a config.
+    """
+    from . import transform
+    if api is not None:
+        api = importlib.import_module(api)
+        set_config_api(api.query_config, api.update_config)
+    click.echo(transform.query_config(key))
+
+
 @click.command()
 @click.argument('workflow')
 @click.option('--code', '-c', default=None, help='The path of the code.')
@@ -94,9 +152,13 @@ def run(workflow, code, data, api, plot, no_dependents):
     data = Path(os.path.expanduser(data))
 
     if no_dependents:
-        run_workflow(workflow, code, data, plot=plot)
+        run_workflow(load_workflow(workflow, code), code, data, plot=plot)
     else:
-        maintain_workflow(workflow, code, data, run=True, plot=plot)
+        maintain_workflow(load_workflow(workflow, code),
+                          code,
+                          data,
+                          run=True,
+                          plot=plot)
 
 
 @click.command()
@@ -121,12 +183,18 @@ def maintain(workflow, code, data, api, plot):
     code = Path(os.path.expanduser(code))
     data = Path(os.path.expanduser(data))
 
-    maintain_workflow(workflow, code, data, run=False, plot=plot)
+    maintain_workflow(load_workflow(workflow, code),
+                      code,
+                      data,
+                      run=False,
+                      plot=plot)
 
 
 cli.add_command(maintain)
 cli.add_command(run)
 cli.add_command(create)
+cli.add_command(set)
+cli.add_command(get)
 
 if __name__ == '__main__':
     cli()

qulab/executor/load.py

@@ -1,10 +1,14 @@
+import hashlib
 import inspect
+import pickle
+import re
+import string
 import warnings
 from importlib.util import module_from_spec, spec_from_file_location
 from pathlib import Path
 from types import ModuleType
 
-import loguru
+from loguru import logger
 
 from .storage import Result
 
@@ -124,12 +128,15 @@ def find_unreferenced_workflows(path: str) -> list[str]:
     for file_path in root.rglob("*.py"):
         if file_path.name == "__init__.py":
             continue
+        if file_path.name.endswith("_template.py") or re.match(
+                r'.*_tmp_[0-9a-fA-F]{8}.py', file_path.name):
+            continue
         try:
             rel_path = file_path.relative_to(root)
         except ValueError:
             continue
 
-        module = load_workflow(str(rel_path), root)
+        module = load_workflow_from_module(str(rel_path), root)
 
         if is_workflow(module):
             rel_str = str(rel_path)
@@ -140,7 +147,7 @@ def find_unreferenced_workflows(path: str) -> list[str]:
 
     # Check dependencies for each workflow module
     for rel_str in workflows:
-        module = load_workflow(rel_str, root)
+        module = load_workflow_from_module(rel_str, root)
 
         depends_func = getattr(module, "depends", None)
         if depends_func and callable(depends_func):
@@ -156,11 +163,9 @@ def find_unreferenced_workflows(path: str) -> list[str]:
                 continue
 
             if not isinstance(depends_list, list) or not all(
-                isinstance(item, str) for item in depends_list
-            ):
+                    isinstance(item, str) for item in depends_list):
                 warnings.warn(
-                    f"depends() in {rel_str} did not return a list of strings"
-                )
+                    f"depends() in {rel_str} did not return a list of strings")
                 continue
 
             for dep in depends_list:
@@ -178,9 +183,9 @@ def find_unreferenced_workflows(path: str) -> list[str]:
     return unreferenced
 
 
-def load_workflow(file_name: str,
-                  base_path: str | Path,
-                  package='workflows') -> WorkflowType:
+def load_workflow_from_module(file_name: str,
+                              base_path: str | Path,
+                              package='workflows') -> WorkflowType:
     if file_name.startswith('cfg:'):
         return SetConfigWorkflow(file_name[4:])
     base_path = Path(base_path)
@@ -200,3 +205,60 @@ def load_workflow(file_name: str,
     verify_check_method(module)
 
     return module
+
+
+def load_workflow_from_template(file_name: str,
+                                mappping: dict[str, str],
+                                base_path: str | Path,
+                                subtitle: str | None = None,
+                                package='workflows') -> WorkflowType:
+    base_path = Path(base_path)
+    path = Path(file_name)
+
+    with open(base_path / path) as f:
+        content = f.read()
+    template = string.Template(content)
+    content = template.substitute(mappping)
+
+    hash_str = hashlib.md5(pickle.dumps(mappping)).hexdigest()[:8]
+    if subtitle is None:
+        path = path.parent / path.stem.replace('_template',
+                                               f'_tmp{hash_str}.py')
+    else:
+        path = path.parent / path.stem.replace('_template', f'_{subtitle}.py')
+
+    with open(base_path / path, 'w') as f:
+        f.write(content)
+
+    module = load_workflow_from_module(str(path), base_path, package)
+
+    return module
+
+
+def load_workflow(workflow: str | tuple[str, dict],
+                  base_path: str | Path,
+                  package='workflows') -> WorkflowType:
+    if isinstance(workflow, tuple):
+        if len(workflow) == 2:
+            file_name, mapping = workflow
+            w = load_workflow_from_template(file_name, mapping, base_path,
+                                            None, package)
+        elif len(workflow) == 3:
+            file_name, subtitle, mapping = workflow
+            w = load_workflow_from_template(file_name, mapping, base_path,
+                                            subtitle, package)
+        else:
+            raise ValueError(f"Invalid workflow: {workflow}")
+        w.__workflow_id__ = str(Path(w.__file__).relative_to(base_path))
+    elif isinstance(workflow, str):
+        if workflow.startswith('cfg:'):
+            key = workflow[4:]
+            w = SetConfigWorkflow(key)
+            w.__workflow_id__ = workflow
+        else:
+            w = load_workflow_from_module(workflow, base_path, package)
+            w.__workflow_id__ = str(Path(w.__file__).relative_to(base_path))
+    else:
+        raise TypeError(f"Invalid workflow: {workflow}")
+
+    return w

qulab/executor/schedule.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from loguru import logger
 
 from . import transform
-from .load import load_workflow
+from .load import WorkflowType, load_workflow
 from .storage import (Result, find_result, get_head, renew_result,
                       revoke_result, save_result)
 
@@ -15,7 +15,7 @@ class CalibrationFailedError(Exception):
     pass
 
 
-def check_state(workflow: str, code_path: str | Path,
+def check_state(workflow: WorkflowType, code_path: str | Path,
                 state_path: str | Path) -> bool:
     """
     check state should report a pass if and only if the following are satisfied:
@@ -26,35 +26,42 @@ def check_state(workflow: str, code_path: str | Path,
     4. All dependencies pass check state.
     """
     logger.debug(f'check_state: "{workflow}"')
-    result = find_result(workflow, state_path)
+    result = find_result(workflow.__workflow_id__, state_path)
     if not result:
-        logger.debug(f'check_state failed: No history found for "{workflow}"')
+        logger.debug(
+            f'check_state failed: No history found for "{workflow.__workflow_id__}"'
+        )
         return False
-    node = load_workflow(workflow, code_path)
-    if hasattr(node, 'check_state') and callable(node.check_state):
+    if hasattr(workflow, 'check_state') and callable(workflow.check_state):
+        logger.debug(
+            f'check_state: "{workflow.__workflow_id__}" has custom check_state method'
+        )
+        return workflow.check_state(result)
+    if workflow.__timeout__ is not None and datetime.now(
+    ) > result.checked_time + timedelta(seconds=workflow.__timeout__):
         logger.debug(
-            f'check_state: "{workflow}" has custom check_state method')
-        return node.check_state(result)
-    if node.__timeout__ is not None and datetime.now(
-    ) > result.checked_time + timedelta(seconds=node.__timeout__):
-        logger.debug(f'check_state failed: "{workflow}" has expired')
+            f'check_state failed: "{workflow.__workflow_id__}" has expired')
         return False
     if not result.in_spec:
-        logger.debug(f'check_state failed: "{workflow}" is out of spec')
+        logger.debug(
+            f'check_state failed: "{workflow.__workflow_id__}" is out of spec')
         return False
     if result.bad_data:
-        logger.debug(f'check_state failed: "{workflow}" has bad data')
+        logger.debug(
+            f'check_state failed: "{workflow.__workflow_id__}" has bad data')
         return False
     for n in get_dependents(workflow, code_path):
-        r = find_result(n, state_path)
+        r = find_result(n.__workflow_id__, state_path)
         if r is None or r.checked_time > result.checked_time:
             logger.debug(
-                f'check_state failed: "{workflow}" has outdated dependencies')
+                f'check_state failed: "{workflow.__workflow_id__}" has outdated dependencies'
+            )
             return False
     for n in get_dependents(workflow, code_path):
         if not check_state(n, code_path, state_path):
             logger.debug(
-                f'check_state failed: "{workflow}" has bad dependencies')
+                f'check_state failed: "{workflow.__workflow_id__}" has bad dependencies'
+            )
             return False
     return True
 
@@ -83,132 +90,153 @@ def call_plot(node, result, check=False):
 
 
 @functools.lru_cache(maxsize=128)
-def check_data(workflow: str, code_path: str | Path, state_path: str | Path,
-               plot: bool, session_id: str) -> Result:
+def check_data(workflow: WorkflowType, code_path: str | Path,
+               state_path: str | Path, plot: bool, session_id: str) -> Result:
     """
     check data answers two questions:
     Is the parameter associated with this cal in spec,
     and is the cal scan working as expected?
     """
-    node = load_workflow(workflow, code_path)
-    history = find_result(workflow, state_path)
+    history = find_result(workflow.__workflow_id__, state_path)
 
     if history is None:
-        logger.debug(f'No history found for "{workflow}"')
+        logger.debug(f'No history found for "{workflow.__workflow_id__}"')
         result = Result()
         result.in_spec = False
         result.bad_data = False
         return result
 
     if history.bad_data:
-        logger.debug(f'History found for "{workflow}", but bad data')
+        logger.debug(
+            f'History found for "{workflow.__workflow_id__}", but bad data')
         return history
     if not history.in_spec:
-        logger.debug(f'History found for "{workflow}", but out of spec')
+        logger.debug(
+            f'History found for "{workflow.__workflow_id__}", but out of spec')
         return history
 
-    logger.debug(f'History found for "{workflow}", but has expired')
+    logger.debug(
+        f'History found for "{workflow.__workflow_id__}", but has expired')
 
-    if hasattr(node, 'check') and callable(node.check) and hasattr(
-            node, 'check_analyze') and callable(node.check_analyze):
+    if hasattr(workflow, 'check') and callable(workflow.check) and hasattr(
+            workflow, 'check_analyze') and callable(workflow.check_analyze):
         logger.debug(f'Checking "{workflow}" with "check" method ...')
-        data = node.check()
+        data = workflow.check()
         result = Result()
         result.data = data
-        save_result(workflow, result, state_path)
+        save_result(workflow.__workflow_id__, result, state_path)
 
         logger.debug(f'Checked "{workflow}" !')
-        result = call_analyzer(node, data, history, check=True, plot=plot)
+        result = call_analyzer(workflow, data, history, check=True, plot=plot)
         if result.in_spec:
-            logger.debug(f'"{workflow}": checked in spec, renewing result')
-            renew_result(workflow, state_path)
+            logger.debug(
+                f'"{workflow.__workflow_id__}": checked in spec, renewing result'
+            )
+            renew_result(workflow.__workflow_id__, state_path)
         else:
-            logger.debug(f'"{workflow}": checked out of spec, revoking result')
-            revoke_result(workflow, state_path)
+            logger.debug(
+                f'"{workflow.__workflow_id__}": checked out of spec, revoking result'
+            )
+            revoke_result(workflow.__workflow_id__, state_path)
     else:
-        logger.debug(f'Checking "{workflow}" with "calibrate" method ...')
-        data = node.calibrate()
+        logger.debug(
+            f'Checking "{workflow.__workflow_id__}" with "calibrate" method ...'
+        )
+        data = workflow.calibrate()
         result = Result()
         result.data = data
-        save_result(workflow, result, state_path)
+        save_result(workflow.__workflow_id__, result, state_path)
 
         logger.debug(f'Calibrated "{workflow}" !')
-        result = call_analyzer(node, data, history, check=False, plot=plot)
-        save_result(workflow, result, state_path,
-                    get_head(workflow, state_path))
+        result = call_analyzer(workflow, data, history, check=False, plot=plot)
+        save_result(workflow.__workflow_id__, result, state_path,
+                    get_head(workflow.__workflow_id__, state_path))
 
     return result
 
 
 @functools.lru_cache(maxsize=128)
-def calibrate(workflow, code_path: str | Path, state_path: str | Path,
-              plot: bool, session_id: str) -> Result:
-    node = load_workflow(workflow, code_path)
-    history = find_result(workflow, state_path)
+def calibrate(workflow: WorkflowType, code_path: str | Path,
+              state_path: str | Path, plot: bool, session_id: str) -> Result:
+    history = find_result(workflow.__workflow_id__, state_path)
 
-    logger.debug(f'Calibrating "{workflow}" ...')
-    data = node.calibrate()
+    logger.debug(f'Calibrating "{workflow.__workflow_id__}" ...')
+    data = workflow.calibrate()
     result = Result()
     result.data = data
-    save_result(workflow, result, state_path)
-    logger.debug(f'Calibrated "{workflow}" !')
-    result = call_analyzer(node, data, history, check=False, plot=plot)
-    save_result(workflow, result, state_path, get_head(workflow, state_path))
+    save_result(workflow.__workflow_id__, result, state_path)
+    logger.debug(f'Calibrated "{workflow.__workflow_id__}" !')
+    result = call_analyzer(workflow, data, history, check=False, plot=plot)
+    save_result(workflow.__workflow_id__, result, state_path,
+                get_head(workflow.__workflow_id__, state_path))
     return result
 
 
-def diagnose(node, code_path: str | Path, state_path: str | Path, plot: bool,
-             session_id: str):
+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 "{node}"')
+    logger.debug(f'diagnose "{workflow.__workflow_id__}"')
     # check_data
-    result = check_data(node, code_path, state_path, plot, session_id)
+    result = check_data(workflow, code_path, state_path, plot, session_id)
     # in spec case
     if result.in_spec:
-        logger.debug(f'"{node}": Checked! In spec, no need to diagnose')
+        logger.debug(
+            f'"{workflow.__workflow_id__}": Checked! In spec, no need to diagnose'
+        )
         return False
     # bad data case
     recalibrated = []
     if result.bad_data:
-        logger.debug(f'"{node}": Bad data, diagnosing dependents')
+        logger.debug(
+            f'"{workflow.__workflow_id__}": Bad data, diagnosing dependents')
         recalibrated = [
             diagnose(n, code_path, state_path, plot, session_id)
-            for n in get_dependents(node, code_path)
+            for n in get_dependents(workflow, code_path)
         ]
     if not any(recalibrated):
         if result.bad_data:
             raise CalibrationFailedError(
-                f'"{node}": bad data but no dependents recalibrated.')
-        logger.debug(f'"{node}": no dependents recalibrated.')
+                f'"{workflow.__workflow_id__}": bad data but no dependents recalibrated.'
+            )
+        logger.debug(
+            f'"{workflow.__workflow_id__}": no dependents recalibrated.')
     # calibrate
     if any(recalibrated):
         logger.debug(
-            f'recalibrate "{node}" because some dependents recalibrated.')
+            f'recalibrate "{workflow.__workflow_id__}" because some dependents recalibrated.'
+        )
     elif not result.in_spec and not result.bad_data:
-        logger.debug(f'recalibrate "{node}" because out of spec.')
+        logger.debug(
+            f'recalibrate "{workflow.__workflow_id__}" because out of spec.')
     elif result.in_spec:
-        logger.error(f'Never reach: recalibrate "{node}" because in spec.')
+        logger.error(
+            f'Never reach: recalibrate "{workflow.__workflow_id__}" because in spec.'
+        )
     elif result.bad_data:
-        logger.error(f'Never reach: recalibrate "{node}" because bad data.')
+        logger.error(
+            f'Never reach: recalibrate "{workflow.__workflow_id__}" because bad data.'
+        )
     else:
-        logger.error(f'Never reach: recalibrate "{node}"')
+        logger.error(f'Never reach: recalibrate "{workflow.__workflow_id__}"')
 
-    result = calibrate(node, code_path, state_path, plot, session_id)
+    result = calibrate(workflow, code_path, state_path, plot, session_id)
     if result.bad_data or not result.in_spec:
         raise CalibrationFailedError(
-            f'"{node}": All dependents passed, but calibration failed!')
+            f'"{workflow.__workflow_id__}": All dependents passed, but calibration failed!'
+        )
     transform.update_parameters(result)
     return True
 
 
-def get_dependents(workflow: str, code_path: str | Path) -> list[str]:
-    return [n for n in load_workflow(workflow, code_path).depends()[0]]
+def get_dependents(workflow: WorkflowType,
+                   code_path: str | Path) -> list[WorkflowType]:
+    return [load_workflow(n, code_path) for n in workflow.depends()[0]]
 
 
 @logger.catch(reraise=True)
-def maintain(node,
+def maintain(workflow: WorkflowType,
              code_path: str | Path,
              state_path: str | Path,
              session_id: str | None = None,
@@ -216,49 +244,61 @@ def maintain(node,
              plot: bool = False):
     if session_id is None:
         session_id = uuid.uuid4().hex
-    logger.debug(f'run "{node}"' if run else f'maintain "{node}"')
+    logger.debug(f'run "{workflow.__workflow_id__}"'
+                 if run else f'maintain "{workflow.__workflow_id__}"')
     # recursive maintain
-    for n in get_dependents(node, code_path):
-        logger.debug(f'maintain "{n}" because it is depended by "{node}"')
+    for n in get_dependents(workflow, code_path):
+        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)
     else:
-        logger.debug(f'"{node}": All dependents maintained')
+        logger.debug(
+            f'"{workflow.__workflow_id__}": All dependents maintained')
     # check_state
-    if check_state(node, code_path, state_path) and not run:
-        logger.debug(f'"{node}": In spec, no need to maintain')
+    if check_state(workflow, code_path, state_path) and not run:
+        logger.debug(
+            f'"{workflow.__workflow_id__}": In spec, no need to maintain')
         return
     # check_data
-    result = check_data(node, code_path, state_path, plot, session_id)
+    result = check_data(workflow, code_path, state_path, plot, session_id)
     if result.in_spec:
         if not run:
-            logger.debug(f'"{node}": In spec, no need to maintain')
+            logger.debug(
+                f'"{workflow.__workflow_id__}": In spec, no need to maintain')
             return
     elif result.bad_data:
-        logger.debug(f'"{node}": Bad data, diagnosing dependents')
-        for n in get_dependents(node, code_path):
-            logger.debug(f'diagnose "{n}" because of "{node}" bad data')
+        logger.debug(
+            f'"{workflow.__workflow_id__}": Bad data, diagnosing dependents')
+        for n in get_dependents(workflow, code_path):
+            logger.debug(
+                f'diagnose "{n.__workflow_id__}" because of "{workflow.__workflow_id__}" bad data'
+            )
             diagnose(n, code_path, state_path, plot, session_id)
         else:
-            logger.debug(f'"{node}": All dependents diagnosed')
+            logger.debug(
+                f'"{workflow.__workflow_id__}": All dependents diagnosed')
     # calibrate
-    logger.debug(f'recalibrate "{node}"')
-    result = calibrate(node, code_path, state_path, plot, session_id)
+    logger.debug(f'recalibrate "{workflow.__workflow_id__}"')
+    result = calibrate(workflow, code_path, state_path, plot, session_id)
     if result.bad_data or not result.in_spec:
         raise CalibrationFailedError(
-            f'"{node}": All dependents passed, but calibration failed!')
+            f'"{workflow.__workflow_id__}": All dependents passed, but calibration failed!'
+        )
     transform.update_parameters(result)
     return
 
 
 @logger.catch(reraise=True)
-def run(node,
+def run(workflow: WorkflowType,
         code_path: str | Path,
         state_path: str | Path,
         plot: bool = False):
-    logger.debug(f'run "{node}" without dependences.')
-    result = calibrate(node, code_path, state_path, plot)
+    logger.debug(f'run "{workflow.__workflow_id__}" without dependences.')
+    result = calibrate(workflow, code_path, state_path, plot)
     if result.bad_data or not result.in_spec:
         raise CalibrationFailedError(
-            f'"{node}": All dependents passed, but calibration failed!')
+            f'"{workflow.__workflow_id__}": All dependents passed, but calibration failed!'
+        )
     transform.update_parameters(result)
     return

qulab/version.py

@@ -1 +1 @@
-__version__ = "2.4.10"
+__version__ = "2.4.12"