QuLab 2.7.6__tar.gz → 2.7.7__tar.gz

{qulab-2.7.6 → qulab-2.7.7}/PKG-INFO

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

{qulab-2.7.6 → qulab-2.7.7}/QuLab.egg-info/PKG-INFO

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

{qulab-2.7.6 → qulab-2.7.7}/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-2.7.6 → qulab-2.7.7}/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-2.7.6 → qulab-2.7.7}/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-2.7.6 → qulab-2.7.7}/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_heads, renew_report,
+                      revoke_report, 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,14 +56,14 @@ 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'
         )
@@ -80,8 +80,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 +90,23 @@ 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 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 +120,115 @@ def check_state(workflow: WorkflowType, code_path: str | Path,
     return True
 
 
-def call_analyzer(node,
-                  result: Result,
-                  history: Result | None,
+def call_analyzer(node: WorkflowType,
+                  report: Report,
+                  history: Report | None,
                   check=False,
-                  plot=False) -> Result:
+                  plot=False) -> Report:
     if check:
-        result = node.check_analyze(result, history=history)
-        veryfy_analyzed_result(result, node.__workflow_id__, "check_analyze")
-        result.fully_calibrated = False
+        report = node.check_analyze(report, history=history)
+        veryfy_analyzed_report(report, node.__workflow_id__, "check_analyze")
+        report.fully_calibrated = False
     else:
-        result = node.analyze(result, history=history)
-        veryfy_analyzed_result(result, node.__workflow_id__, "analyze")
+        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:
-                result = node.oracle(result,
+                report = node.oracle(report,
                                      history=history,
-                                     system_state=get_heads(result.base_path))
+                                     system_state=get_heads(report.base_path))
             except Exception as e:
                 logger.exception(e)
-                result.oracle = {}
-            if not isinstance(result, Result):
+                report.oracle = {}
+            if not isinstance(report, Report):
                 raise TypeError(
-                    f'"{node.__workflow_id__}" : function "oracle" must return a Result object'
+                    f'"{node.__workflow_id__}" : function "oracle" must return a Report object'
                 )
-            if not is_pickleable(result.oracle):
+            if not is_pickleable(report.oracle):
                 raise TypeError(
                     f'"{node.__workflow_id__}" : function "oracle" return not pickleable data'
                 )
-        result.fully_calibrated = True
+        report.fully_calibrated = True
         if plot:
-            call_plot(node, result)
-    return result
+            call_plot(node, report)
+    return report
 
 
 @logger.catch()
-def call_plot(node, result: Result, check=False):
+def call_plot(node: WorkflowType, report: Report, check=False):
     if hasattr(node, 'plot') and callable(node.plot):
-        node.plot(result)
+        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))
+
+    save_report(workflow.__workflow_id__,
+                report,
+                state_path,
+                refresh_heads=False)
+
+    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))
+
+    save_report(workflow.__workflow_id__, report, state_path)
+
+    set_cache(session_id, (workflow, 'calibrate'), report)
+    return report
 
 
 def check_data(workflow: WorkflowType, code_path: str | Path,
-               state_path: str | Path, plot: bool, session_id: str) -> Result:
+               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
+        report.in_spec = False
+        report.bad_data = False
+        return report
 
     if history.bad_data:
         logger.debug(
@@ -202,92 +246,59 @@ 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,
+        report = call_analyzer(workflow,
+                               report,
                                history,
                                check=True,
                                plot=plot)
-        if result.in_spec:
+        if report.in_spec:
             logger.debug(
-                f'"{workflow.__workflow_id__}": checked in spec, renewing result'
+                f'"{workflow.__workflow_id__}": checked in spec, renewing report'
             )
-            renew_result(workflow.__workflow_id__, state_path)
+            renew_report(workflow.__workflow_id__, report, state_path)
         else:
             logger.debug(
-                f'"{workflow.__workflow_id__}": checked out of spec, revoking result'
+                f'"{workflow.__workflow_id__}": checked out of spec, revoking report'
             )
-            revoke_result(workflow.__workflow_id__, state_path)
+            revoke_report(workflow.__workflow_id__, report, state_path)
     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,
                                plot=plot)
-        save_result(workflow.__workflow_id__,
-                    result,
+        save_report(workflow.__workflow_id__,
+                    report,
                     state_path,
                     overwrite=True)
-
-    set_cache(session_id, (workflow, 'check_data'), result)
-    return result
+    return report
 
 
 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
-
-    history = find_result(workflow.__workflow_id__, state_path)
+              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__}" ...')
-    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, 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, check=False, plot=plot)
+
+    save_report(workflow.__workflow_id__, report, state_path, overwrite=True)
+    return report
 
 
 def diagnose(workflow: WorkflowType, code_path: str | Path,
@@ -297,16 +308,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, code_path, 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 +325,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 +336,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, code_path, 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 +393,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, code_path, 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 +412,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, code_path, 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 +432,17 @@ def run(workflow: WorkflowType,
         freeze: bool = False):
     session_id = uuid.uuid4().hex
     logger.debug(f'run "{workflow.__workflow_id__}" without dependences.')
-    result = calibrate(workflow,
+    report = calibrate(workflow,
                        code_path,
                        state_path,
                        plot,
                        session_id=session_id)
-    if result.bad_data or not result.in_spec:
+    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