QuLab 2.6.0__tar.gz → 2.6.2__tar.gz

{qulab-2.6.0 → qulab-2.6.2}/PKG-INFO

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

{qulab-2.6.0 → qulab-2.6.2}/QuLab.egg-info/PKG-INFO

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

{qulab-2.6.0 → qulab-2.6.2}/qulab/__init__.py

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

{qulab-2.6.0 → qulab-2.6.2}/qulab/executor/cli.py

@@ -12,6 +12,7 @@ from .load import (WorkflowType, find_unreferenced_workflows, get_entries,
                    load_workflow, make_graph)
 from .schedule import maintain as maintain_workflow
 from .schedule import run as run_workflow
+from .schedule import CalibrationFailedError
 from .transform import set_config_api
 from .utils import workflow_template
 
@@ -135,16 +136,20 @@ def get(key, api):
               '-n',
               is_flag=True,
               help='Do not run dependents.')
+@click.option('--retry', '-r', default=1, type=int, help='Retry times.')
 @click.option('--update', '-u', is_flag=True)
 @log_options
 @command_option('run')
-def run(workflow, code, data, api, plot, no_dependents, update):
+def run(workflow, code, data, api, plot, no_dependents, retry, update):
     """
     Run a workflow.
     """
     logger.info(
-        f'[CMD]: run {workflow} --code {code} --data {data} --api {api}{" --plot" if plot else ""}{" --no-dependents" if no_dependents else ""}{" --update " if update else ""}'
-    )
+        f'[CMD]: run {workflow} --code {code} --data {data} --api {api}'
+        f'{" --plot" if plot else ""}'
+        f'{" --no-dependents" if no_dependents else ""}'
+        f' --retry {retry}'
+        f'{" --update " if update else ""}')
     if api is not None:
         api = importlib.import_module(api)
         set_config_api(api.query_config, api.update_config, api.export_config)
@@ -159,42 +164,56 @@ def run(workflow, code, data, api, plot, no_dependents, update):
     wf = load_workflow(workflow, code)
     check_toplogy(wf, code)
 
-    if no_dependents:
-        if hasattr(wf, 'entries'):
-            for entry in get_entries(wf, code):
-                run_workflow(entry, code, data, plot=plot, update=update)
-        else:
-            run_workflow(wf, code, data, plot=plot, update=update)
-    else:
-        if hasattr(wf, 'entries'):
-            for entry in get_entries(wf, code):
-                maintain_workflow(entry,
-                                  code,
-                                  data,
-                                  run=True,
-                                  plot=plot,
-                                  update=update)
-        else:
-            maintain_workflow(wf,
-                              code,
-                              data,
-                              run=True,
-                              plot=plot,
-                              update=update)
+    for i in range(retry):
+        try:
+            if no_dependents:
+                if hasattr(wf, 'entries'):
+                    for entry in get_entries(wf, code):
+                        run_workflow(entry,
+                                     code,
+                                     data,
+                                     plot=plot,
+                                     update=update)
+                else:
+                    run_workflow(wf, code, data, plot=plot, update=update)
+            else:
+                if hasattr(wf, 'entries'):
+                    for entry in get_entries(wf, code):
+                        maintain_workflow(entry,
+                                          code,
+                                          data,
+                                          run=True,
+                                          plot=plot,
+                                          update=update)
+                else:
+                    maintain_workflow(wf,
+                                      code,
+                                      data,
+                                      run=True,
+                                      plot=plot,
+                                      update=update)
+            break
+        except CalibrationFailedError as e:
+            if i == retry - 1:
+                raise e
+            logger.warning(f'Calibration failed, retrying ({i + 1}/{retry})')
+            continue
 
 
 @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.')
 @log_options
 @command_option('maintain')
-def maintain(workflow, code, data, api, plot):
+def maintain(workflow, code, data, api, retry, plot):
     """
     Maintain a workflow.
     """
     logger.info(
-        f'[CMD]: maintain {workflow} --code {code} --data {data} --api {api}{" --plot" if plot else ""}'
-    )
+        f'[CMD]: maintain {workflow} --code {code} --data {data} --api {api}'
+        f' --retry {retry}'
+        f'{" --plot" if plot else ""}')
     if api is not None:
         api = importlib.import_module(api)
         set_config_api(api.query_config, api.update_config, api.export_config)
@@ -209,8 +228,15 @@ def maintain(workflow, code, data, api, plot):
     wf = load_workflow(workflow, code)
     check_toplogy(wf, code)
 
-    if hasattr(wf, 'entries'):
-        for entry in get_entries(wf, code):
-            maintain_workflow(entry, code, data, run=False, plot=plot)
-    else:
-        maintain_workflow(wf, code, data, run=False, plot=plot)
+    for i in range(retry):
+        try:
+            if hasattr(wf, 'entries'):
+                for entry in get_entries(wf, code):
+                    maintain_workflow(entry, code, data, run=False, plot=plot)
+            else:
+                maintain_workflow(wf, code, data, run=False, plot=plot)
+        except CalibrationFailedError as e:
+            if i == retry - 1:
+                raise e
+            logger.warning(f'Calibration failed, retrying ({i + 1}/{retry})')
+            continue

{qulab-2.6.0 → qulab-2.6.2}/qulab/executor/load.py

@@ -123,7 +123,7 @@ def verify_check_method(module: WorkflowType):
 
 
 def verify_dependence_key(workflow: str | tuple[str, dict[str, Any]]
-                          | tuple[str, str, dict[str, Any]]):
+                          | tuple[str, str, dict[str, Any]], base_path: Path):
     if isinstance(workflow, str):
         return
     if not isinstance(workflow, tuple) or len(workflow) not in [2, 3]:
@@ -135,7 +135,7 @@ def verify_dependence_key(workflow: str | tuple[str, dict[str, Any]]
             raise FileNotFoundError(f"File not found: {file_name}")
     elif len(workflow) == 3:
         template_path, target_path, mapping = workflow
-        if not Path(template_path).exists():
+        if not (Path(base_path) / template_path).exists():
             raise FileNotFoundError(f"File not found: {template_path}")
         if not isinstance(target_path, (Path, str)) or target_path == '':
             raise ValueError(f"Invalid target_path: {target_path}")
@@ -165,7 +165,7 @@ def verify_dependence_key(workflow: str | tuple[str, dict[str, Any]]
     return
 
 
-def verify_depends(module: WorkflowType):
+def verify_depends(module: WorkflowType, base_path):
     if not hasattr(module, 'depends'):
         return
 
@@ -184,10 +184,10 @@ def verify_depends(module: WorkflowType):
             f"Workflow {module.__file__} 'depends' should be a callable or a list"
         )
     for workflow in deps:
-        verify_dependence_key(workflow)
+        verify_dependence_key(workflow, base_path)
 
 
-def verify_entries(module: WorkflowType):
+def verify_entries(module: WorkflowType, base_path):
     if not hasattr(module, 'entries'):
         return
 
@@ -206,7 +206,7 @@ def verify_entries(module: WorkflowType):
             f"Workflow {module.__file__} 'entries' should be a callable or a list"
         )
     for workflow in deps:
-        verify_dependence_key(workflow)
+        verify_dependence_key(workflow, base_path)
 
 
 def is_workflow(module: ModuleType) -> bool:
@@ -307,7 +307,7 @@ def load_workflow_from_file(file_name: str,
     module.__mtime__ = (base_path / path).stat().st_mtime
 
     if hasattr(module, 'entries'):
-        verify_entries(module)
+        verify_entries(module, base_path)
         return module
 
     if not hasattr(module, '__timeout__'):
@@ -315,7 +315,7 @@ def load_workflow_from_file(file_name: str,
 
     if not hasattr(module, 'depends'):
         module.depends = lambda: []
-    verify_depends(module)
+    verify_depends(module, base_path)
     verify_calibrate_method(module)
     verify_check_method(module)
 

{qulab-2.6.0 → qulab-2.6.2}/qulab/executor/schedule.py

@@ -125,7 +125,8 @@ def check_data(workflow: WorkflowType, code_path: str | Path,
     if history is None:
         logger.debug(f'No history found for "{workflow.__workflow_id__}"')
         result = Result(workflow=workflow.__workflow_id__,
-                        config_path=current_config(state_path))
+                        config_path=current_config(state_path),
+                        base_path=state_path)
         result.in_spec = False
         result.bad_data = False
         return result
@@ -153,7 +154,8 @@ def check_data(workflow: WorkflowType, code_path: str | Path,
             )
         result = Result(workflow=workflow.__workflow_id__,
                         data=data,
-                        config_path=current_config(state_path))
+                        config_path=current_config(state_path),
+                        base_path=state_path)
         #save_result(workflow.__workflow_id__, result, state_path)
 
         logger.debug(f'Checked "{workflow.__workflow_id__}" !')
@@ -183,7 +185,8 @@ def check_data(workflow: WorkflowType, code_path: str | Path,
             )
         result = Result(workflow=workflow.__workflow_id__,
                         data=data,
-                        config_path=current_config(state_path))
+                        config_path=current_config(state_path),
+                        base_path=state_path)
         save_result(workflow.__workflow_id__, result, state_path)
 
         logger.debug(f'Calibrated "{workflow}" !')
@@ -213,7 +216,8 @@ def calibrate(workflow: WorkflowType, code_path: str | Path,
         )
     result = Result(workflow=workflow.__workflow_id__,
                     data=data,
-                    config_path=current_config(state_path))
+                    config_path=current_config(state_path),
+                    base_path=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)

{qulab-2.6.0 → qulab-2.6.2}/qulab/executor/storage.py

@@ -1,3 +1,4 @@
+import hashlib
 import lzma
 import pickle
 import uuid
@@ -50,9 +51,8 @@ class Result():
 
     @property
     def config(self):
-        from . import transform
         if self.config_path is not None and self.base_path is not None:
-            return transform._load_config(self.config_path, self.base_path)
+            return load_config(self.config_path, self.base_path)
         else:
             return None
 
@@ -241,3 +241,35 @@ def get_result_by_index(
         return load_result(path, base_path)
     except:
         return None
+
+
+def save_config(cfg, data_path):
+    i = 0
+    buf = pickle.dumps(cfg)
+    buf = lzma.compress(buf)
+    h = hashlib.md5(buf)
+
+    while True:
+        salt = f"{i}".encode()
+        h.update(salt)
+        hashstr = h.hexdigest()
+        cfg_id = Path(hashstr[:2]) / hashstr[2:4] / hashstr[4:]
+        path = Path(data_path) / 'config' / cfg_id
+        if not path.exists():
+            path.parent.mkdir(parents=True, exist_ok=True)
+            with open(path, 'wb') as f:
+                f.write(buf)
+            break
+        elif path.read_bytes() == buf:
+            break
+        i += 1
+    return str(cfg_id)
+
+
+@lru_cache(maxsize=1024)
+def load_config(id, data_path):
+    path = Path(data_path) / 'config' / id
+    with open(path, 'rb') as f:
+        buf = f.read()
+    cfg = pickle.loads(lzma.decompress(buf))
+    return cfg

{qulab-2.6.0 → qulab-2.6.2}/qulab/executor/transform.py

@@ -1,12 +1,6 @@
-import functools
-import hashlib
-import lzma
-import pickle
-from pathlib import Path
+from .storage import Result, save_config
 
-from .storage import Result
-
-__config_id = None
+__current_config_id = None
 
 
 def _query_config(name: str, default=None):
@@ -50,52 +44,18 @@ def _export_config() -> dict:
 
 
 def update_parameters(result: Result, data_path):
-    global __config_id
+    global __current_config_id
     update_config(result.parameters)
     cfg = export_config()
-    __config_id = _save_config(cfg, data_path)
+    __current_config_id = save_config(cfg, data_path)
 
 
 def current_config(data_path):
-    global __config_id
-    if __config_id is None:
+    global __current_config_id
+    if __current_config_id is None:
         cfg = export_config()
-        __config_id = _save_config(cfg, data_path)
-    return __config_id
-
-
-def _save_config(cfg, data_path):
-    global __config_id
-    i = 0
-    buf = pickle.dumps(cfg)
-    buf = lzma.compress(buf)
-    h = hashlib.md5(buf)
-
-    while True:
-        salt = f"{i:08d}".encode()
-        h.update(salt)
-        hashstr = h.hexdigest()
-        cfg_id = Path(hashstr[:2]) / hashstr[2:4] / hashstr[4:]
-        path = Path(data_path) / 'config' / cfg_id
-        if not path.exists():
-            path.parent.mkdir(parents=True, exist_ok=True)
-            with open(path, 'wb') as f:
-                f.write(buf)
-            break
-        elif path.read_bytes() == buf:
-            break
-        i += 1
-    __config_id = str(cfg_id)
-    return __config_id
-
-
-@functools.lru_cache(maxsize=1024)
-def _load_config(id, data_path):
-    path = Path(data_path) / 'config' / id
-    with open(path, 'rb') as f:
-        buf = f.read()
-    cfg = pickle.loads(lzma.decompress(buf))
-    return cfg
+        __current_config_id = save_config(cfg, data_path)
+    return __current_config_id
 
 
 query_config = _query_config

{qulab-2.6.0 → qulab-2.6.2}/qulab/executor/utils.py

@@ -138,8 +138,8 @@ def check_analyze(result: Result, history: Result | None = None) -> Result:
 
 def debug_analyze(
         result_index: int,
-        code_path: str | Path = get_config_value('code_path', Path),
-        data_path: str | Path = get_config_value('data_path', Path),
+        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
 
@@ -150,7 +150,7 @@ def debug_analyze(
     wf = load_workflow(workflow, code_path)
     if wf is None:
         raise ValueError(f'Invalid workflow: {workflow}')
-    result = wf.analyze(result)
+    result = wf.analyze(result, result.previous)
     if hasattr(wf, 'plot'):
         wf.plot(result)
     return result

qulab-2.6.2/qulab/version.py

@@ -0,0 +1 @@
+__version__ = "2.6.2"

qulab-2.6.0/qulab/version.py

@@ -1 +0,0 @@
-__version__ = "2.6.0"