QuLab 2.7.6__cp310-cp310-macosx_10_9_universal2.whl → 2.7.10__cp310-cp310-macosx_10_9_universal2.whl

{QuLab-2.7.6.dist-info → QuLab-2.7.10.dist-info}/METADATA

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

{QuLab-2.7.6.dist-info → QuLab-2.7.10.dist-info}/RECORD

@@ -1,20 +1,20 @@
-qulab/__init__.py,sha256=tKRZe2WafDGcwbu7ddlMaePerN842aRbxcrECsu5pas,286
+qulab/__init__.py,sha256=KJcUcZ5qXY6wlAoirzK_B-dgtDjsLmOE671v3gcXO_c,286
 qulab/__main__.py,sha256=fjaRSL_uUjNIzBGNgjlGswb9TJ2VD5qnkZHW3hItrD4,68
 qulab/dicttree.py,sha256=tRRMpGZYVOLw0TEByE3_2Ss8FdOmzuGL9e1DWbs8qoY,13684
-qulab/fun.cpython-310-darwin.so,sha256=QgEHTFx4ediOVIUKGllGdaak8zXnkawvicMAoWGO33E,126864
-qulab/typing.py,sha256=5xCLfrp1aZpKpDy4p2arbFszw2eK3hGUjZa-XSvC_-8,69
+qulab/fun.cpython-310-darwin.so,sha256=onm3XhLaPD33T04UQ2QP32Gkl2E9xWjH45aY_Aqwjc0,126864
+qulab/typing.py,sha256=vg62sGqxuD9CI5677ejlzAmf2fVdAESZCQjAE_xSxPg,69
 qulab/utils.py,sha256=JIXMSmZU0uYfKG_tzawpK7vRNPRir_hJE8JlqkVLX2o,1260
-qulab/version.py,sha256=ElxLmcD9H2GsJrWa-NsuGSxQyl8yztVfJ8oaA66f8oQ,21
+qulab/version.py,sha256=jdPSCkDOwzHQzdidl89buWuyX5dorFZluLWAvXtMdIU,22
 qulab/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/cli/commands.py,sha256=tgDIkkeIoasQXAifJZ6NU8jDgpNgb2a-B0C4nF0evrE,559
 qulab/cli/config.py,sha256=SdNmWzweWAdyk8M2oKYhMxnkaJ0qIayPlsLGCNlVqME,3108
 qulab/executor/__init__.py,sha256=LosPzOMaljSZY1thy_Fxtbrgq7uubJszMABEB7oM7tU,101
-qulab/executor/cli.py,sha256=n0wl27xaiMWg18rVDOaKgLTEXaN0tSv4whTUQxvzBoM,8932
-qulab/executor/load.py,sha256=RJpgDuxNc3sUzr65K6a4vO-Qa72_lYsJGrPZDfw9Rus,18077
-qulab/executor/schedule.py,sha256=jBUK0vXeu-gbieSaH245exlGu3TW6vg9o0GIEF43IvA,16796
-qulab/executor/storage.py,sha256=k8rcyUHaAixMtWRTNfQrjFhingYqBb0fJZwHBLVE_UM,11002
-qulab/executor/transform.py,sha256=kaDJePBhVc32gZkQN8YBuA69lYYW9YhDZmCnUKaWuQw,2189
-qulab/executor/utils.py,sha256=XDk3duNrqDsCqZyZUmPqIAIIiykiafcOMBpy9NVAOAw,5686
+qulab/executor/cli.py,sha256=gGka2M6xccfM8facsIJ2qZ1y2Yx8C4BRhc1JG6nK9mo,8932
+qulab/executor/load.py,sha256=4FY_SwumLDUewC265v4j_ZGGpfYOgH4c8PtglYcWpBw,18077
+qulab/executor/schedule.py,sha256=S8zRdkM2_I9-EqMUCEGI9boe3sfc68Gn5NRK057ShAw,17997
+qulab/executor/storage.py,sha256=gI6g28BmKKEZ_Pl-hFwvpiOj3mF8Su-yjj3hfMXs1VY,11630
+qulab/executor/transform.py,sha256=4DyGXv1Iw36cCPqbqXlsn0Lw6gFjQpp_6Hcta50YQxU,2181
+qulab/executor/utils.py,sha256=cF6-2jlvlHyTjNHdxXKG04Fjfm3_3wfDQAF1G8DQphk,5686
 qulab/monitor/__init__.py,sha256=nTHelnDpxRS_fl_B38TsN0njgq8eVTEz9IAnN3NbDlM,42
 qulab/monitor/__main__.py,sha256=w3yUcqq195LzSnXTkQcuC1RSFRhy4oQ_PEBmucXguME,97
 qulab/monitor/config.py,sha256=fQ5JcsMApKc1UwANEnIvbDQZl8uYW0tle92SaYtX9lI,744
@@ -94,9 +94,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.7.6.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
-QuLab-2.7.6.dist-info/METADATA,sha256=CUCFSSV87lDFOp15xOhzDpvmL3P7TMje6GOlrckku_E,3698
-QuLab-2.7.6.dist-info/WHEEL,sha256=Yd3eJSBM2hj8W-ouaiMfFUwQYAS-D6P73Ob9yN5MZd0,114
-QuLab-2.7.6.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
-QuLab-2.7.6.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-QuLab-2.7.6.dist-info/RECORD,,
+QuLab-2.7.10.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
+QuLab-2.7.10.dist-info/METADATA,sha256=-3XSmnAFhNexNzMEufmMAAUF2JfWg2YL_7crqvgyIPg,3699
+QuLab-2.7.10.dist-info/WHEEL,sha256=Yd3eJSBM2hj8W-ouaiMfFUwQYAS-D6P73Ob9yN5MZd0,114
+QuLab-2.7.10.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
+QuLab-2.7.10.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+QuLab-2.7.10.dist-info/RECORD,,

qulab/__init__.py

@@ -1,5 +1,5 @@
-from .executor.storage import find_result
-from .executor.storage import get_result_by_index as get_result
+from .executor.storage import find_report
+from .executor.storage import get_report_by_index as get_report
 from .executor.utils import debug_analyze
 from .scan import Scan, get_record, load_record, lookup, lookup_list
 from .version import __version__

qulab/executor/cli.py

@@ -149,7 +149,7 @@ def get(key, api):
 
 @click.command()
 @click.argument('workflow')
-@click.option('--plot', '-p', is_flag=True, help='Plot the result.')
+@click.option('--plot', '-p', is_flag=True, help='Plot the report.')
 @click.option('--no-dependents',
               '-n',
               is_flag=True,
@@ -221,7 +221,7 @@ def run(workflow, code, data, api, plot, no_dependents, retry, freeze):
 @click.command()
 @click.argument('workflow')
 @click.option('--retry', '-r', default=1, type=int, help='Retry times.')
-@click.option('--plot', '-p', is_flag=True, help='Plot the result.')
+@click.option('--plot', '-p', is_flag=True, help='Plot the report.')
 @log_options
 @command_option('maintain')
 def maintain(workflow, code, data, api, retry, plot):

qulab/executor/load.py

@@ -15,7 +15,7 @@ from typing import Any
 
 from loguru import logger
 
-from .storage import Result
+from .storage import Report
 
 
 class SetConfigWorkflow():
@@ -29,7 +29,7 @@ class SetConfigWorkflow():
     def depends(self):
         return []
 
-    def check_state(self, history: Result) -> bool:
+    def check_state(self, history: Report) -> bool:
         from . import transform
         try:
             return self._equal(history.parameters[self.key],
@@ -45,21 +45,21 @@ class SetConfigWorkflow():
             value = eval(input(f'"{self.key}": '))
         return value
 
-    def analyze(self, result: Result, history: Result):
-        result.state = 'OK'
-        result.parameters = {self.key: result.data}
-        return result
+    def analyze(self, report: Report, history: Report):
+        report.state = 'OK'
+        report.parameters = {self.key: report.data}
+        return report
 
     def check(self):
         return self.calibrate()
 
-    def check_analyze(self, result: Result, history: Result | None):
+    def check_analyze(self, report: Report, history: Report | None):
         if self.check_state(history):
-            result.state = 'OK'
-            result.parameters = {self.key: history.data}
+            report.state = 'OK'
+            report.parameters = {self.key: history.data}
         else:
-            result.state = 'Outdated'
-        return result
+            report.state = 'Outdated'
+        return report
 
     @staticmethod
     def _equal(a, b):

qulab/executor/schedule.py

@@ -7,28 +7,28 @@ from pathlib import Path
 from loguru import logger
 
 from .load import WorkflowType, get_dependents
-from .storage import (Result, find_result, get_heads, renew_result,
-                      revoke_result, save_result)
+from .storage import (Report, find_report, get_head, get_heads, renew_report,
+                      revoke_report, save_item, save_report)
 from .transform import current_config, obey_the_oracle, update_parameters
 
 __session_id = None
 __session_cache = {}
 
 
-def set_cache(session_id, key, result: Result):
+def set_cache(session_id, key, report: Report):
     global __session_id
     if __session_id is None:
         __session_id = session_id
     if __session_id != session_id:
         __session_cache.clear()
-    if result.workflow.startswith('cfg:'):
-        __session_cache[key] = result
+    if report.workflow.startswith('cfg:'):
+        __session_cache[key] = report
     else:
-        __session_cache[key] = result.base_path, result.path
+        __session_cache[key] = report.base_path, report.path
 
 
-def get_cache(session_id, key) -> Result:
-    from .storage import load_result
+def get_cache(session_id, key) -> Report:
+    from .storage import load_report
     global __session_id
     if __session_id is None or __session_id != session_id:
         return None
@@ -37,8 +37,8 @@ def get_cache(session_id, key) -> Result:
         return None
     if isinstance(index, tuple):
         base_path, path = index
-        return load_result(base_path, path)
-    elif isinstance(index, Result):
+        return load_report(base_path, path)
+    elif isinstance(index, Report):
         return index
     else:
         return None
@@ -56,19 +56,29 @@ def is_pickleable(obj) -> bool:
         return False
 
 
-def veryfy_analyzed_result(result: Result, script: str, method: str):
-    if not isinstance(result, Result):
-        raise TypeError(f'"{script}" : "{method}" must return a Result object')
-    if not is_pickleable(result.parameters):
+def veryfy_analyzed_report(report: Report, script: str, method: str):
+    if not isinstance(report, Report):
+        raise TypeError(f'"{script}" : "{method}" must return a Report object')
+    if not is_pickleable(report.parameters):
         raise TypeError(
             f'"{script}" : "{method}" return not pickleable data in .parameters'
         )
-    if not is_pickleable(result.other_infomation):
+    if not is_pickleable(report.other_infomation):
         raise TypeError(
             f'"{script}" : "{method}" return not pickleable data in .other_infomation'
         )
 
 
+def get_source(workflow: WorkflowType, code_path: str | Path) -> str:
+    if isinstance(code_path, str):
+        code_path = Path(code_path)
+    try:
+        with open(code_path / workflow.__workflow_id__, 'r') as f:
+            return f.read()
+    except:
+        return ''
+
+
 def check_state(workflow: WorkflowType, code_path: str | Path,
                 state_path: str | Path) -> bool:
     """
@@ -80,8 +90,8 @@ def check_state(workflow: WorkflowType, code_path: str | Path,
     4. All dependencies pass check state.
     """
     logger.debug(f'check_state: "{workflow.__workflow_id__}"')
-    result = find_result(workflow.__workflow_id__, state_path)
-    if not result:
+    report = find_report(workflow.__workflow_id__, state_path)
+    if not report:
         logger.debug(
             f'check_state failed: No history found for "{workflow.__workflow_id__}"'
         )
@@ -90,23 +100,28 @@ def check_state(workflow: WorkflowType, code_path: str | Path,
         logger.debug(
             f'check_state: "{workflow.__workflow_id__}" has custom check_state method'
         )
-        return workflow.check_state(result)
+        return workflow.check_state(report)
+    if datetime.fromtimestamp(workflow.__mtime__) > report.checked_time:
+        logger.debug(
+            f'check_state failed: "{workflow.__workflow_id__}" has been modified after last calibration'
+        )
+        return False
     if workflow.__timeout__ is not None and datetime.now(
-    ) > result.checked_time + timedelta(seconds=workflow.__timeout__):
+    ) > report.checked_time + timedelta(seconds=workflow.__timeout__):
         logger.debug(
             f'check_state failed: "{workflow.__workflow_id__}" has expired')
         return False
-    if not result.in_spec:
+    if not report.in_spec:
         logger.debug(
             f'check_state failed: "{workflow.__workflow_id__}" is out of spec')
         return False
-    if result.bad_data:
+    if report.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.__workflow_id__, state_path)
-        if r is None or r.checked_time > result.checked_time:
+        r = find_report(n.__workflow_id__, state_path)
+        if r is None or r.checked_time > report.checked_time:
             logger.debug(
                 f'check_state failed: "{workflow.__workflow_id__}" has outdated dependencies'
             )
@@ -120,71 +135,146 @@ def check_state(workflow: WorkflowType, code_path: str | Path,
     return True
 
 
-def call_analyzer(node,
-                  result: Result,
-                  history: Result | None,
-                  check=False,
-                  plot=False) -> Result:
-    if check:
-        result = node.check_analyze(result, history=history)
-        veryfy_analyzed_result(result, node.__workflow_id__, "check_analyze")
-        result.fully_calibrated = False
+@logger.catch()
+def call_plot(node: WorkflowType, report: Report, check=False):
+    if hasattr(node, 'plot') and callable(node.plot):
+        node.plot(report)
+
+
+def call_check(workflow: WorkflowType, session_id: str, state_path: Path):
+    report = get_cache(session_id, (workflow, 'check'))
+    if report is not None:
+        logger.debug(f'Cache hit for "{workflow.__workflow_id__}:check"')
+        return report
+
+    data = workflow.check()
+    if not is_pickleable(data):
+        raise TypeError(
+            f'"{workflow.__workflow_id__}" : "check" return not pickleable data'
+        )
+    report = Report(workflow=workflow.__workflow_id__,
+                    data=data,
+                    config_path=current_config(state_path),
+                    base_path=state_path,
+                    heads=get_heads(state_path),
+                    previous_path=get_head(workflow.__workflow_id__,
+                                           state_path),
+                    script_path=save_item(get_source(workflow, state_path),
+                                          state_path))
+
+    save_report(workflow.__workflow_id__, report, state_path)
+
+    set_cache(session_id, (workflow, 'check'), report)
+    return report
+
+
+def call_calibrate(workflow: WorkflowType, session_id: str, state_path: Path):
+    report = get_cache(session_id, (workflow, 'calibrate'))
+    if report is not None:
+        logger.debug(f'Cache hit for "{workflow.__workflow_id__}:calibrate"')
+        return report
+
+    data = workflow.calibrate()
+    if not is_pickleable(data):
+        raise TypeError(
+            f'"{workflow.__workflow_id__}" : "calibrate" return not pickleable data'
+        )
+    report = Report(workflow=workflow.__workflow_id__,
+                    data=data,
+                    config_path=current_config(state_path),
+                    base_path=state_path,
+                    heads=get_heads(state_path),
+                    previous_path=get_head(workflow.__workflow_id__,
+                                           state_path),
+                    script_path=save_item(get_source(workflow, state_path),
+                                          state_path))
+
+    save_report(workflow.__workflow_id__, report, state_path)
+
+    set_cache(session_id, (workflow, 'calibrate'), report)
+    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)
+    veryfy_analyzed_report(report, node.__workflow_id__, "check_analyze")
+    report.fully_calibrated = False
+    if report.in_spec:
+        logger.debug(
+            f'"{node.__workflow_id__}": checked in spec, renewing report')
+        if report.previous is not None:
+            renew_report(node.__workflow_id__, report.previous, state_path)
+        else:
+            renew_report(node.__workflow_id__, report, state_path)
     else:
-        result = node.analyze(result, history=history)
-        veryfy_analyzed_result(result, node.__workflow_id__, "analyze")
-        if hasattr(node, 'oracle') and callable(node.oracle):
-            logger.debug(
-                f'"{node.__workflow_id__}" has oracle method, calling ...')
-            try:
-                result = node.oracle(result,
-                                     history=history,
-                                     system_state=get_heads(result.base_path))
-            except Exception as e:
-                logger.exception(e)
-                result.oracle = {}
-            if not isinstance(result, Result):
-                raise TypeError(
-                    f'"{node.__workflow_id__}" : function "oracle" must return a Result object'
-                )
-            if not is_pickleable(result.oracle):
-                raise TypeError(
-                    f'"{node.__workflow_id__}" : function "oracle" return not pickleable data'
-                )
-        result.fully_calibrated = True
-        if plot:
-            call_plot(node, result)
-    return result
+        logger.debug(
+            f'"{node.__workflow_id__}": checked out of spec, revoking report')
+        if report.previous is not None:
+            revoke_report(node.__workflow_id__, report.previous, state_path)
+        else:
+            revoke_report(node.__workflow_id__, report, state_path)
+    return report
 
 
-@logger.catch()
-def call_plot(node, result: Result, check=False):
-    if hasattr(node, 'plot') and callable(node.plot):
-        node.plot(result)
+def call_analyzer(node: WorkflowType,
+                  report: Report,
+                  history: Report | None,
+                  state_path: Path,
+                  plot=False) -> Report:
+
+    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 ...')
+        try:
+            report = node.oracle(report,
+                                 history=history,
+                                 system_state=get_heads(report.base_path))
+        except Exception as e:
+            logger.exception(e)
+            report.oracle = {}
+        if not isinstance(report, Report):
+            raise TypeError(
+                f'"{node.__workflow_id__}" : function "oracle" must return a Report object'
+            )
+        if not is_pickleable(report.oracle):
+            raise TypeError(
+                f'"{node.__workflow_id__}" : function "oracle" return not pickleable data'
+            )
+    report.fully_calibrated = True
+    save_report(node.__workflow_id__, report, state_path, overwrite=True)
+    if plot:
+        call_plot(node, report)
+    return report
 
 
-def check_data(workflow: WorkflowType, code_path: str | Path,
-               state_path: str | Path, plot: bool, session_id: str) -> Result:
+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,
     and is the cal scan working as expected?
     """
-    result = get_cache(session_id, (workflow, 'check_data'))
-    if result is not None:
-        logger.debug(f'Cache hit for "{workflow.__workflow_id__}:check_data"')
-        return result
-
-    history = find_result(workflow.__workflow_id__, state_path)
+    history = find_report(workflow.__workflow_id__, state_path)
 
     if history is None:
         logger.debug(f'No history found for "{workflow.__workflow_id__}"')
-        result = Result(workflow=workflow.__workflow_id__,
+        report = Report(workflow=workflow.__workflow_id__,
                         config_path=current_config(state_path),
                         base_path=state_path,
-                        heads=get_heads(state_path))
-        result.in_spec = False
-        result.bad_data = False
-        return result
+                        heads=get_heads(state_path),
+                        previous_path=get_head(workflow.__workflow_id__,
+                                               state_path),
+                        script_path=save_item(get_source(workflow, state_path),
+                                              state_path))
+        report.in_spec = False
+        report.bad_data = False
+        return report
 
     if history.bad_data:
         logger.debug(
@@ -202,92 +292,43 @@ def check_data(workflow: WorkflowType, code_path: str | Path,
             workflow, 'check_analyze') and callable(workflow.check_analyze):
         logger.debug(
             f'Checking "{workflow.__workflow_id__}" with "check" method ...')
-        data = workflow.check()
-        if not is_pickleable(data):
-            raise TypeError(
-                f'"{workflow.__workflow_id__}" : "check" return not pickleable data'
-            )
-        result = Result(workflow=workflow.__workflow_id__,
-                        data=data,
-                        config_path=current_config(state_path),
-                        base_path=state_path,
-                        heads=get_heads(state_path))
-        #save_result(workflow.__workflow_id__, result, state_path)
+
+        report = call_check(workflow, session_id, state_path)
 
         logger.debug(f'Checked "{workflow.__workflow_id__}" !')
-        result = call_analyzer(workflow,
-                               result,
-                               history,
-                               check=True,
-                               plot=plot)
-        if result.in_spec:
-            logger.debug(
-                f'"{workflow.__workflow_id__}": checked in spec, renewing result'
-            )
-            renew_result(workflow.__workflow_id__, state_path)
-        else:
-            logger.debug(
-                f'"{workflow.__workflow_id__}": checked out of spec, revoking result'
-            )
-            revoke_result(workflow.__workflow_id__, state_path)
+        report = call_check_analyzer(workflow,
+                                     report,
+                                     history,
+                                     state_path,
+                                     plot=plot)
     else:
         logger.debug(
             f'Checking "{workflow.__workflow_id__}" with "calibrate" method ...'
         )
-        data = workflow.calibrate()
-        if not is_pickleable(data):
-            raise TypeError(
-                f'"{workflow.__workflow_id__}" : "calibrate" return not pickleable data'
-            )
-        result = Result(workflow=workflow.__workflow_id__,
-                        data=data,
-                        config_path=current_config(state_path),
-                        base_path=state_path,
-                        heads=get_heads(state_path))
-        save_result(workflow.__workflow_id__, result, state_path)
+
+        report = call_calibrate(workflow, session_id, state_path)
 
         logger.debug(f'Calibrated "{workflow.__workflow_id__}" !')
-        result = call_analyzer(workflow,
-                               result,
+        report = call_analyzer(workflow,
+                               report,
                                history,
-                               check=False,
+                               state_path,
                                plot=plot)
-        save_result(workflow.__workflow_id__,
-                    result,
-                    state_path,
-                    overwrite=True)
+    return report
 
-    set_cache(session_id, (workflow, 'check_data'), result)
-    return result
 
+def calibrate(workflow: WorkflowType, state_path: str | Path, plot: bool,
+              session_id: str) -> Report:
+    history = find_report(workflow.__workflow_id__, state_path)
 
-def calibrate(workflow: WorkflowType, code_path: str | Path,
-              state_path: str | Path, plot: bool, session_id: str) -> Result:
-    result = get_cache(session_id, (workflow, 'calibrate'))
-    if result is not None:
-        logger.debug(f'Cache hit for "{workflow.__workflow_id__}:calibrate"')
-        return result
+    logger.debug(f'Calibrating "{workflow.__workflow_id__}" ...')
 
-    history = find_result(workflow.__workflow_id__, state_path)
+    report = call_calibrate(workflow, session_id, state_path)
 
-    logger.debug(f'Calibrating "{workflow.__workflow_id__}" ...')
-    data = workflow.calibrate()
-    if not is_pickleable(data):
-        raise TypeError(
-            f'"{workflow.__workflow_id__}" : "calibrate" return not pickleable data'
-        )
-    result = Result(workflow=workflow.__workflow_id__,
-                    data=data,
-                    config_path=current_config(state_path),
-                    base_path=state_path,
-                    heads=get_heads(state_path))
-    save_result(workflow.__workflow_id__, result, state_path)
     logger.debug(f'Calibrated "{workflow.__workflow_id__}" !')
-    result = call_analyzer(workflow, result, history, check=False, plot=plot)
-    save_result(workflow.__workflow_id__, result, state_path, overwrite=True)
 
-    set_cache(session_id, (workflow, 'calibrate'), result)
-    return result
+    report = call_analyzer(workflow, report, history, state_path, plot=plot)
+    return report
 
 
 def diagnose(workflow: WorkflowType, code_path: str | Path,
@@ -297,16 +338,16 @@ def diagnose(workflow: WorkflowType, code_path: str | Path,
     '''
     logger.debug(f'diagnose "{workflow.__workflow_id__}"')
     # check_data
-    result = check_data(workflow, code_path, state_path, plot, session_id)
+    report = check_data(workflow, state_path, plot, session_id)
     # in spec case
-    if result.in_spec:
+    if report.in_spec:
         logger.debug(
             f'"{workflow.__workflow_id__}": Checked! In spec, no need to diagnose'
         )
         return False
     # bad data case
     recalibrated = []
-    if result.bad_data:
+    if report.bad_data:
         logger.debug(
             f'"{workflow.__workflow_id__}": Bad data, diagnosing dependents')
         recalibrated = [
@@ -314,7 +355,7 @@ def diagnose(workflow: WorkflowType, code_path: str | Path,
             for n in get_dependents(workflow, code_path)
         ]
     if not any(recalibrated):
-        if result.bad_data:
+        if report.bad_data:
             raise CalibrationFailedError(
                 f'"{workflow.__workflow_id__}": bad data but no dependents recalibrated.'
             )
@@ -325,27 +366,27 @@ def diagnose(workflow: WorkflowType, code_path: str | Path,
         logger.debug(
             f'recalibrate "{workflow.__workflow_id__}" because some dependents recalibrated.'
         )
-    elif not result.in_spec and not result.bad_data:
+    elif not report.in_spec and not report.bad_data:
         logger.debug(
             f'recalibrate "{workflow.__workflow_id__}" because out of spec.')
-    elif result.in_spec:
+    elif report.in_spec:
         logger.error(
             f'Never reach: recalibrate "{workflow.__workflow_id__}" because in spec.'
         )
-    elif result.bad_data:
+    elif report.bad_data:
         logger.error(
             f'Never reach: recalibrate "{workflow.__workflow_id__}" because bad data.'
         )
     else:
         logger.error(f'Never reach: recalibrate "{workflow.__workflow_id__}"')
 
-    result = calibrate(workflow, code_path, state_path, plot, session_id)
-    if result.bad_data or not result.in_spec:
-        obey_the_oracle(result, state_path)
+    report = calibrate(workflow, state_path, plot, session_id)
+    if report.bad_data or not report.in_spec:
+        obey_the_oracle(report, state_path)
         raise CalibrationFailedError(
             f'"{workflow.__workflow_id__}": All dependents passed, but calibration failed!'
         )
-    update_parameters(result, state_path)
+    update_parameters(report, state_path)
     return True
 
 
@@ -382,13 +423,13 @@ def maintain(workflow: WorkflowType,
             f'"{workflow.__workflow_id__}": In spec, no need to maintain')
         return
     # check_data
-    result = check_data(workflow, code_path, state_path, plot, session_id)
-    if result.in_spec:
+    report = check_data(workflow, state_path, plot, session_id)
+    if report.in_spec:
         if not run:
             logger.debug(
                 f'"{workflow.__workflow_id__}": In spec, no need to maintain')
             return
-    elif result.bad_data:
+    elif report.bad_data:
         logger.debug(
             f'"{workflow.__workflow_id__}": Bad data, diagnosing dependents')
         for n in get_dependents(workflow, code_path):
@@ -401,15 +442,15 @@ def maintain(workflow: WorkflowType,
                 f'"{workflow.__workflow_id__}": All dependents diagnosed')
     # calibrate
     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:
+    report = calibrate(workflow, state_path, plot, session_id)
+    if report.bad_data or not report.in_spec:
         if not freeze:
-            obey_the_oracle(result, state_path)
+            obey_the_oracle(report, state_path)
         raise CalibrationFailedError(
             f'"{workflow.__workflow_id__}": All dependents passed, but calibration failed!'
         )
     if not freeze:
-        update_parameters(result, state_path)
+        update_parameters(report, state_path)
     return
 
 
@@ -421,17 +462,13 @@ def run(workflow: WorkflowType,
         freeze: bool = False):
     session_id = uuid.uuid4().hex
     logger.debug(f'run "{workflow.__workflow_id__}" without dependences.')
-    result = calibrate(workflow,
-                       code_path,
-                       state_path,
-                       plot,
-                       session_id=session_id)
-    if result.bad_data or not result.in_spec:
+    report = calibrate(workflow, state_path, plot, session_id=session_id)
+    if report.bad_data or not report.in_spec:
         if not freeze:
-            obey_the_oracle(result, state_path)
+            obey_the_oracle(report, state_path)
         raise CalibrationFailedError(
             f'"{workflow.__workflow_id__}": All dependents passed, but calibration failed!'
         )
     if not freeze:
-        update_parameters(result, state_path)
+        update_parameters(report, state_path)
     return

qulab/executor/storage.py

@@ -16,7 +16,7 @@ __current_config_cache = None
 
 
 @dataclass
-class Result():
+class Report():
     workflow: str = ''
     in_spec: bool = False
     bad_data: bool = False
@@ -34,11 +34,12 @@ class Result():
     base_path: Path | None = field(default=None, repr=False)
     path: Path | None = field(default=None, repr=False)
     config_path: Path | None = field(default=None, repr=False)
+    script_path: Path | None = field(default=None, repr=False)
 
     @property
     def previous(self):
         if self.previous_path is not None and self.base_path is not None:
-            return load_result(self.previous_path, self.base_path)
+            return load_report(self.previous_path, self.base_path)
         else:
             return None
 
@@ -54,13 +55,6 @@ class Result():
                 state = 'Outdated'
         return state
 
-    @property
-    def config(self):
-        if self.config_path is not None and self.base_path is not None:
-            return load_config(self.config_path, self.base_path)
-        else:
-            return None
-
     @state.setter
     def state(self, state: Literal['OK', 'Bad', 'Outdated', 'In spec',
                                    'Out of spec', 'Bad data']):
@@ -80,6 +74,20 @@ class Result():
             self.bad_data = False
             self.in_spec = False
 
+    @property
+    def config(self):
+        if self.config_path is not None and self.base_path is not None:
+            return load_item(self.config_path, self.base_path)
+        else:
+            return None
+
+    @property
+    def script(self):
+        if self.script_path is not None and self.base_path is not None:
+            return load_item(self.script_path, self.base_path)
+        else:
+            return None
+
 
 def random_path(base: Path) -> Path:
     while True:
@@ -89,7 +97,7 @@ def random_path(base: Path) -> Path:
             return path
 
 
-def save_config_key_history(key: str, result: Result,
+def save_config_key_history(key: str, report: Report,
                             base_path: str | Path) -> int:
     global __current_config_cache
     base_path = Path(base_path) / 'state'
@@ -103,14 +111,14 @@ def save_config_key_history(key: str, result: Result,
             __current_config_cache = {}
 
     __current_config_cache[
-        key] = result.data, result.calibrated_time, result.checked_time
+        key] = report.data, report.calibrated_time, report.checked_time
 
     with open(base_path / 'parameters.pkl', 'wb') as f:
         pickle.dump(__current_config_cache, f)
     return 0
 
 
-def find_config_key_history(key: str, base_path: str | Path) -> Result | None:
+def find_config_key_history(key: str, base_path: str | Path) -> Report | None:
     global __current_config_cache
     base_path = Path(base_path) / 'state'
     if __current_config_cache is None:
@@ -123,7 +131,7 @@ def find_config_key_history(key: str, base_path: str | Path) -> Result | None:
     if key in __current_config_cache:
         value, calibrated_time, checked_time = __current_config_cache.get(
             key, None)
-        result = Result(
+        report = Report(
             workflow=f'cfg:{key}',
             bad_data=False,
             in_spec=True,
@@ -133,64 +141,65 @@ def find_config_key_history(key: str, base_path: str | Path) -> Result | None:
             calibrated_time=calibrated_time,
             checked_time=checked_time,
         )
-        return result
+        return report
     return None
 
 
-def save_result(workflow: str,
-                result: Result,
+def save_report(workflow: str,
+                report: Report,
                 base_path: str | Path,
-                overwrite: bool = False) -> int:
+                overwrite: bool = False,
+                refresh_heads: bool = True) -> int:
     if workflow.startswith("cfg:"):
-        return save_config_key_history(workflow[4:], result, base_path)
+        return save_config_key_history(workflow[4:], report, base_path)
 
     logger.debug(
-        f'Saving result for "{workflow}", {result.in_spec=}, {result.bad_data=}, {result.fully_calibrated=}'
+        f'Saving report for "{workflow}", {report.in_spec=}, {report.bad_data=}, {report.fully_calibrated=}'
     )
     base_path = Path(base_path)
+    try:
+        buf = lzma.compress(pickle.dumps(report))
+    except:
+        raise ValueError(f"Can't pickle report for {workflow}")
     if overwrite:
-        buf = lzma.compress(pickle.dumps(result))
-        path = result.path
+        path = report.path
         if path is None:
-            path = get_head(workflow, base_path)
-            result.path = path
-        with open(base_path / 'objects' / path, "rb") as f:
+            raise ValueError("Report path is None, can't overwrite.")
+        with open(base_path / 'reports' / path, "rb") as f:
             index = int.from_bytes(f.read(8), 'big')
-        result.index = index
+        report.index = index
     else:
-        result.previous_path = get_head(workflow, base_path)
-        buf = lzma.compress(pickle.dumps(result))
-        path = random_path(base_path / 'objects')
-        (base_path / 'objects' / path).parent.mkdir(parents=True,
+        path = random_path(base_path / 'reports')
+        (base_path / 'reports' / path).parent.mkdir(parents=True,
                                                     exist_ok=True)
-        result.path = path
-        result.index = create_index("result",
+        report.path = path
+        report.index = create_index("report",
                                     base_path,
                                     context=str(path),
                                     width=35)
-
-    with open(base_path / 'objects' / path, "wb") as f:
-        f.write(result.index.to_bytes(8, 'big'))
+    with open(base_path / 'reports' / path, "wb") as f:
+        f.write(report.index.to_bytes(8, 'big'))
         f.write(buf)
-    set_head(workflow, path, base_path)
-    return result.index
+    if refresh_heads:
+        set_head(workflow, path, base_path)
+    return report.index
 
 
-def load_result(path: str | Path, base_path: str | Path) -> Result | None:
+def load_report(path: str | Path, base_path: str | Path) -> Report | None:
     base_path = Path(base_path)
-    path = base_path / 'objects' / path
+    path = base_path / 'reports' / path
 
-    with open(base_path / 'objects' / path, "rb") as f:
+    with open(base_path / 'reports' / path, "rb") as f:
         index = int.from_bytes(f.read(8), 'big')
-        result = pickle.loads(lzma.decompress(f.read()))
-        result.base_path = base_path
-        result.index = index
-        return result
+        report = pickle.loads(lzma.decompress(f.read()))
+        report.base_path = base_path
+        report.index = index
+        return report
 
 
-def find_result(
+def find_report(
     workflow: str, base_path: str | Path = get_config_value("data", Path)
-) -> Result | None:
+) -> Report | None:
     if workflow.startswith("cfg:"):
         return find_config_key_history(workflow[4:], base_path)
 
@@ -198,25 +207,33 @@ def find_result(
     path = get_head(workflow, base_path)
     if path is None:
         return None
-    return load_result(path, base_path)
-
-
-def renew_result(workflow: str, base_path: str | Path):
-    logger.debug(f'Renewing result for "{workflow}"')
-    result = find_result(workflow, base_path)
-    if result is not None:
-        result.checked_time = datetime.now()
-        return save_result(workflow, result, base_path)
+    return load_report(path, base_path)
+
+
+def renew_report(workflow: str, report: Report | None, base_path: str | Path):
+    logger.debug(f'Renewing report for "{workflow}"')
+    if report is not None:
+        report.checked_time = datetime.now()
+        return save_report(workflow,
+                           report,
+                           base_path,
+                           overwrite=True,
+                           refresh_heads=True)
+    else:
+        raise ValueError(f"Can't renew report for {workflow}")
 
 
-def revoke_result(workflow: str, base_path: str | Path):
-    logger.debug(f'Revoking result for "{workflow}"')
+def revoke_report(workflow: str, report: Report | None, base_path: str | Path):
+    logger.debug(f'Revoking report for "{workflow}"')
     base_path = Path(base_path)
-    path = get_head(workflow, base_path)
-    if path is not None:
-        result = load_result(path, base_path)
-        result.in_spec = False
-        return save_result(workflow, result, base_path)
+    if report is not None:
+        report.in_spec = False
+        report.previous_path = report.path
+        return save_report(workflow,
+                           report,
+                           base_path,
+                           overwrite=False,
+                           refresh_heads=True)
 
 
 def set_head(workflow: str, path: Path, base_path: str | Path):
@@ -296,28 +313,27 @@ def query_index(name: str, base_path: str | Path, index: int):
     return context.rstrip()
 
 
-def get_result_by_index(
+def get_report_by_index(
     index: int, base_path: str | Path = get_config_value("data", Path)
-) -> Result | None:
+) -> Report | None:
     try:
-        path = query_index("result", base_path, index)
-        return load_result(path, base_path)
+        path = query_index("report", base_path, index)
+        return load_report(path, base_path)
     except:
         return None
 
 
-def save_config(cfg, data_path):
-    i = 0
-    buf = pickle.dumps(cfg)
+def save_item(item, data_path):
+    salt = 0
+    buf = pickle.dumps(item)
     buf = lzma.compress(buf)
     h = hashlib.md5(buf)
 
     while True:
-        salt = f"{i}".encode()
-        h.update(salt)
+        h.update(f"{salt}".encode())
         hashstr = h.hexdigest()
-        cfg_id = Path(hashstr[:2]) / hashstr[2:4] / hashstr[4:]
-        path = Path(data_path) / 'config' / cfg_id
+        item_id = Path(hashstr[:2]) / hashstr[2:4] / hashstr[4:]
+        path = Path(data_path) / 'items' / item_id
         if not path.exists():
             path.parent.mkdir(parents=True, exist_ok=True)
             with open(path, 'wb') as f:
@@ -325,13 +341,13 @@ def save_config(cfg, data_path):
             break
         elif path.read_bytes() == buf:
             break
-        i += 1
-    return str(cfg_id)
+        salt += 1
+    return str(item_id)
 
 
-@lru_cache(maxsize=1024)
-def load_config(id, data_path):
-    path = Path(data_path) / 'config' / id
+@lru_cache(maxsize=4096)
+def load_item(id, data_path):
+    path = Path(data_path) / 'items' / id
     with open(path, 'rb') as f:
         buf = f.read()
     cfg = pickle.loads(lzma.decompress(buf))

qulab/executor/transform.py

@@ -1,4 +1,4 @@
-from .storage import Result, save_config
+from .storage import Report, save_item
 
 __current_config_id = None
 
@@ -43,25 +43,25 @@ def _export_config() -> dict:
     return parameters
 
 
-def obey_the_oracle(result: Result, data_path):
+def obey_the_oracle(report: Report, data_path):
     global __current_config_id
-    update_config(result.oracle)
+    update_config(report.oracle)
     cfg = export_config()
-    __current_config_id = save_config(cfg, data_path)
+    __current_config_id = save_item(cfg, data_path)
 
 
-def update_parameters(result: Result, data_path):
+def update_parameters(report: Report, data_path):
     global __current_config_id
-    update_config(result.parameters)
+    update_config(report.parameters)
     cfg = export_config()
-    __current_config_id = save_config(cfg, data_path)
+    __current_config_id = save_item(cfg, data_path)
 
 
 def current_config(data_path):
     global __current_config_id
     if __current_config_id is None:
         cfg = export_config()
-        __current_config_id = save_config(cfg, data_path)
+        __current_config_id = save_item(cfg, data_path)
     return __current_config_id
 
 

qulab/executor/utils.py

@@ -37,7 +37,7 @@ def workflow_template(workflow: str, deps: list[str]) -> str:
 import numpy as np
 from loguru import logger
 
-from qulab.typing import Result
+from qulab.typing import Report
 
 
 # 多长时间应该检查一次校准实验，单位是秒。
@@ -63,35 +63,35 @@ def calibrate():
     return x, y
 
 
-def analyze(result: Result, history: Result | None = None) -> Result:
+def analyze(report: Report, history: Report | None = None) -> Report:
     \"\"\"
     分析校准结果。
 
-    result: Result
+    report: Report
         本次校准实验的数据。
-    history: Result | None
+    history: Report | None
         上次校准实验数据和分析结果，如果有的话。
     \"\"\"
     import random
 
-    # 这里添加你的分析过程，运行 calibrate 得到的数据，在 result.data 里
+    # 这里添加你的分析过程，运行 calibrate 得到的数据，在 report.data 里
     # 你可以得到校准的结果，然后根据这个结果进行分析。
-    x, y = result.data
+    x, y = report.data
 
     # 完整校准后的状态有两种：OK 和 Bad，分别对应校准成功和校准失败。
     # 校准失败是指出现坏数据，无法简单通过重新运行本次校准解决，需要
     # 检查前置步骤。
-    result.state = random.choice(['OK', 'Bad'])
+    report.state = random.choice(['OK', 'Bad'])
 
     # 参数是一个字典，包含了本次校准得到的参数，后续会更新到config表中。
-    result.parameters = {{'gate.R.Q1.params.amp':1}}
+    report.parameters = {{'gate.R.Q1.params.amp':1}}
 
     # 其他信息可以是任何可序列化的内容，你可以将你想要记录的信息放在这里。
     # 下次校准分析时，这些信息也会在 history 参数中一起传入，帮助你在下
     # 次分析时对比参考。
-    result.other_infomation = {{}}
+    report.other_infomation = {{}}
 
-    return result
+    return report
 
 
 def check():
@@ -111,33 +111,33 @@ def check():
     return x, y
 
 
-def check_analyze(result: Result, history: Result | None = None) -> Result:
+def check_analyze(report: Report, history: Report | None = None) -> Report:
     \"\"\"
     分析检查结果。
 
-    result: Result
+    report: Report
         本次检查实验的数据。
-    history: Result | None
+    history: Report | None
         上次检查实验数据和分析结果，如果有的话。
     \"\"\"
     import random
 
-    # 这里添加你的分析过程，运行 check 得到的数据，在 result.data 里
+    # 这里添加你的分析过程，运行 check 得到的数据，在 report.data 里
     # 你可以得到校准的结果，然后根据这个结果进行分析。
-    x, y = result.data
+    x, y = report.data
 
     # 状态有三种：Outdated, OK, Bad，分别对应过时、正常、坏数据。
     # Outdated 是指数据过时，即参数漂了，需要重新校准。
     # OK 是指数据正常，参数也没漂，不用重新校准。
     # Bad 是指数据坏了，无法校准，需要检查前置步骤。
-    result.state = random.choice(['Outdated', 'OK', 'Bad'])
+    report.state = random.choice(['Outdated', 'OK', 'Bad'])
 
-    return result
+    return report
 
 
-def oracle(result: Result,
-           history: Result | None = None,
-           system_state: dict[str:str] | None = None) -> Result:
+def oracle(report: Report,
+           history: Report | None = None,
+           system_state: dict[str:str] | None = None) -> Report:
     \"\"\"
     谕示：指凭直觉或经验判断，改动某些配置，以期望下次校准成功。
     
@@ -145,31 +145,31 @@ def oracle(result: Result,
     比如通常我们在死活测不到 rabi 或能谱时，会换一个 idle bias 再试试。这
     里我们凭直觉设的那个 bias 值，就是一个谕示，可以通过 oracle 来设定。
 
-    该函数代入的参数 result 是 analyze 函数的返回值。
+    该函数代入的参数 report 是 analyze 函数的返回值。
     \"\"\"
 
-    # result.oracle['Q0.bias'] = 0.1
-    # result.oracle['Q1.bias'] = -0.03
+    # report.oracle['Q0.bias'] = 0.1
+    # report.oracle['Q1.bias'] = -0.03
 
-    return result
+    return report
 """
 
 
 def debug_analyze(
-        result_index: int,
+        report_index: int,
         code_path: str | Path = get_config_value('code', Path),
         data_path: str | Path = get_config_value('data', Path),
 ) -> None:
-    from .storage import get_result_by_index
+    from .storage import get_report_by_index
 
-    result = get_result_by_index(result_index, data_path)
-    if result is None:
-        raise ValueError(f'Invalid result index: {result_index}')
-    workflow = result.workflow
+    report = get_report_by_index(report_index, data_path)
+    if report is None:
+        raise ValueError(f'Invalid report index: {report_index}')
+    workflow = report.workflow
     wf = load_workflow(workflow, code_path)
     if wf is None:
         raise ValueError(f'Invalid workflow: {workflow}')
-    result = wf.analyze(result, result.previous)
+    report = wf.analyze(report, report.previous)
     if hasattr(wf, 'plot'):
-        wf.plot(result)
-    return result
+        wf.plot(report)
+    return report

qulab/typing.py

@@ -1,2 +1,2 @@
-from .executor.storage import Result
+from .executor.storage import Report
 from .scan.record import Record

qulab/version.py

@@ -1 +1 @@
-__version__ = "2.7.6"
+__version__ = "2.7.10"