QuLab 2.10.0__cp311-cp311-win_amd64.whl → 2.10.2__cp311-cp311-win_amd64.whl

qulab/executor/cli.py

@@ -30,11 +30,16 @@ def boot(script_path):
 
 
 @logger.catch(reraise=True)
-def check_toplogy(workflow: WorkflowType, code_path: str | Path) -> dict:
+def check_toplogy(workflow: WorkflowType,
+                  code_path: str | Path,
+                  veryfy_source_code: bool = True) -> dict:
     graph = {}
     try:
-        graphlib.TopologicalSorter(make_graph(workflow, graph,
-                                              code_path)).static_order()
+        graphlib.TopologicalSorter(
+            make_graph(workflow,
+                       graph,
+                       code_path,
+                       veryfy_source_code=veryfy_source_code)).static_order()
     except graphlib.CycleError as e:
         logger.error(
             f"Workflow {workflow.__workflow_id__} has a circular dependency: {e}"
@@ -167,7 +172,15 @@ def get(key, api):
 @log_options
 @command_option('run')
 @async_command
-async def run(workflow, code, data, api, plot, no_dependents, retry, freeze):
+async def run(workflow,
+              code,
+              data,
+              api,
+              plot,
+              no_dependents,
+              retry,
+              freeze,
+              veryfy_source_code=True):
     """
     Run a workflow.
 
@@ -198,41 +211,67 @@ async def run(workflow, code, data, api, plot, no_dependents, retry, freeze):
     code = Path(os.path.expanduser(code))
     data = Path(os.path.expanduser(data))
 
-    wf = load_workflow(workflow, code)
-    check_toplogy(wf, code)
+    wf = load_workflow(workflow, code, veryfy_source_code=veryfy_source_code)
+    check_toplogy(wf, code, veryfy_source_code=veryfy_source_code)
 
     for i in range(retry):
         try:
             if no_dependents:
                 if hasattr(wf, 'entries'):
-                    for entry in get_entries(wf, code):
-                        await run_workflow(entry,
-                                           code,
-                                           data,
-                                           plot=plot,
-                                           freeze=freeze)
+                    exceptions = []
+                    for entry in get_entries(
+                            wf, code, veryfy_source_code=veryfy_source_code):
+                        try:
+                            await run_workflow(
+                                entry,
+                                code,
+                                data,
+                                plot=plot,
+                                freeze=freeze,
+                                veryfy_source_code=veryfy_source_code,
+                            )
+                        except Exception as e:
+                            exceptions.append(e)
+                    if any(exceptions):
+                        raise exceptions[0]
                 else:
-                    await run_workflow(wf,
-                                       code,
-                                       data,
-                                       plot=plot,
-                                       freeze=freeze)
+                    await run_workflow(
+                        wf,
+                        code,
+                        data,
+                        plot=plot,
+                        freeze=freeze,
+                        veryfy_source_code=veryfy_source_code,
+                    )
             else:
                 if hasattr(wf, 'entries'):
-                    for entry in get_entries(wf, code):
-                        await maintain_workflow(entry,
-                                                code,
-                                                data,
-                                                run=True,
-                                                plot=plot,
-                                                freeze=freeze)
+                    exceptions = []
+                    for entry in get_entries(
+                            wf, code, veryfy_source_code=veryfy_source_code):
+                        try:
+                            await maintain_workflow(
+                                entry,
+                                code,
+                                data,
+                                run=True,
+                                plot=plot,
+                                freeze=freeze,
+                                veryfy_source_code=veryfy_source_code,
+                            )
+                        except Exception as e:
+                            exceptions.append(e)
+                    if any(exceptions):
+                        raise exceptions[0]
                 else:
-                    await maintain_workflow(wf,
-                                            code,
-                                            data,
-                                            run=True,
-                                            plot=plot,
-                                            freeze=freeze)
+                    await maintain_workflow(
+                        wf,
+                        code,
+                        data,
+                        run=True,
+                        plot=plot,
+                        freeze=freeze,
+                        veryfy_source_code=veryfy_source_code,
+                    )
             break
         except CalibrationFailedError as e:
             if i == retry - 1:
@@ -248,7 +287,13 @@ async def run(workflow, code, data, api, plot, no_dependents, retry, freeze):
 @log_options
 @command_option('maintain')
 @async_command
-async def maintain(workflow, code, data, api, retry, plot):
+async def maintain(workflow,
+                   code,
+                   data,
+                   api,
+                   retry,
+                   plot,
+                   veryfy_source_code=True):
     """
     Maintain a workflow.
 
@@ -275,26 +320,39 @@ async def maintain(workflow, code, data, api, retry, plot):
     code = Path(os.path.expanduser(code))
     data = Path(os.path.expanduser(data))
 
-    wf = load_workflow(workflow, code)
-    check_toplogy(wf, code)
+    wf = load_workflow(workflow, code, veryfy_source_code=veryfy_source_code)
+    check_toplogy(wf, code, veryfy_source_code=veryfy_source_code)
 
     for i in range(retry):
         try:
             if hasattr(wf, 'entries'):
-                for entry in get_entries(wf, code):
-                    await maintain_workflow(entry,
-                                            code,
-                                            data,
-                                            run=False,
-                                            plot=plot,
-                                            freeze=False)
+                exceptions = []
+                for entry in get_entries(
+                        wf, code, veryfy_source_code=veryfy_source_code):
+                    try:
+                        await maintain_workflow(
+                            entry,
+                            code,
+                            data,
+                            run=False,
+                            plot=plot,
+                            freeze=False,
+                            veryfy_source_code=veryfy_source_code,
+                        )
+                    except Exception as e:
+                        exceptions.append(e)
+                if any(exceptions):
+                    raise exceptions[0]
             else:
-                await maintain_workflow(wf,
-                                        code,
-                                        data,
-                                        run=False,
-                                        plot=plot,
-                                        freeze=False)
+                await maintain_workflow(
+                    wf,
+                    code,
+                    data,
+                    run=False,
+                    plot=plot,
+                    freeze=False,
+                    veryfy_source_code=veryfy_source_code,
+                )
             break
         except CalibrationFailedError as e:
             if i == retry - 1:

qulab/executor/load.py

@@ -1,6 +1,9 @@
 import atexit
 import inspect
 import pickle
+import os
+import time
+import shutil
 import tempfile
 import warnings
 from importlib.util import module_from_spec, spec_from_file_location
@@ -135,10 +138,14 @@ def verify_dependence_key(workflow: str | tuple[str, dict[str, Any]]
     if not isinstance(workflow, tuple) or len(workflow) not in [2, 3]:
         raise ValueError(f"Invalid workflow: {workflow}")
 
-    if len(workflow) == 2:
+    if len(workflow) == 2 and isinstance(workflow[1], str):
         file_name, mapping = workflow
         if not Path(file_name).exists():
             raise FileNotFoundError(f"File not found: {file_name}")
+    elif len(workflow) == 2 and isinstance(workflow[1], dict):
+        template_path, mapping = workflow
+        if not (Path(base_path) / template_path).exists():
+            raise FileNotFoundError(f"File not found: {template_path}")
     elif len(workflow) == 3:
         template_path, target_path, mapping = workflow
         if not (Path(base_path) / template_path).exists():
@@ -301,7 +308,8 @@ def find_unreferenced_workflows(path: str) -> list[str]:
 
 def load_workflow_from_file(file_name: str,
                             base_path: str | Path,
-                            package='workflows') -> WorkflowType:
+                            package='workflows',
+                            veryfy_source_code: bool = True) -> WorkflowType:
     base_path = Path(base_path)
     path = Path(file_name)
     if not (base_path / path).exists():
@@ -315,7 +323,8 @@ def load_workflow_from_file(file_name: str,
     module.__source__ = source_code
 
     if hasattr(module, 'entries'):
-        verify_entries(module, base_path)
+        if veryfy_source_code:
+            verify_entries(module, base_path)
         return module
 
     if not hasattr(module, '__timeout__'):
@@ -323,9 +332,11 @@ def load_workflow_from_file(file_name: str,
 
     if not hasattr(module, 'depends'):
         module.depends = lambda: []
-    verify_depends(module, base_path)
-    verify_calibrate_method(module)
-    verify_check_method(module)
+
+    if veryfy_source_code:
+        verify_depends(module, base_path)
+        verify_calibrate_method(module)
+        verify_check_method(module)
 
     return module
 
@@ -376,12 +387,14 @@ def _generate_target_file_path(template_path: str | Path, hash_str: str,
         return Path('run') / path
 
 
-def load_workflow_from_template(template_path: str,
-                                mapping: dict[str, str],
-                                base_path: str | Path,
-                                target_path: str | None = None,
-                                package='workflows',
-                                mtime: float = 0) -> WorkflowType:
+def load_workflow_from_template(
+        template_path: str,
+        mapping: dict[str, str],
+        base_path: str | Path,
+        target_path: str | None = None,
+        package='workflows',
+        mtime: float = 0,
+        veryfy_source_code: bool = True) -> WorkflowType:
     base_path = Path(base_path)
     path = Path(template_path)
 
@@ -409,7 +422,8 @@ def load_workflow_from_template(template_path: str,
             f"`{file}` already exists and is different from the new one generated from template `{template_path}`"
         )
 
-    module = load_workflow_from_file(str(path), base_path, package)
+    module = load_workflow_from_file(str(path), base_path, package,
+                                     veryfy_source_code)
     module.__mtime__ = max(mtime, module.__mtime__)
     if module.__source__ == content:
         module.__source__ = template, mapping, str(template_path)
@@ -421,26 +435,31 @@ def load_workflow(workflow: str | tuple[str, dict],
                   base_path: str | Path,
                   package='workflows',
                   mtime: float = 0,
-                  inject: dict | None = None) -> WorkflowType:
+                  inject: dict | None = None,
+                  veryfy_source_code: bool = True) -> WorkflowType:
     if isinstance(workflow, tuple):
         if len(workflow) == 2:
             file_name, mapping = workflow
             if inject is None:
                 w = load_workflow_from_template(file_name, mapping, base_path,
-                                                None, package, mtime)
+                                                None, package, mtime,
+                                                veryfy_source_code)
             else:
                 w = load_workflow_from_template(file_name, inject, base_path,
-                                                None, package, mtime)
+                                                None, package, mtime,
+                                                veryfy_source_code)
         elif len(workflow) == 3:
             template_path, target_path, mapping = workflow
             if inject is None:
                 w = load_workflow_from_template(template_path, mapping,
                                                 base_path, target_path,
-                                                package, mtime)
+                                                package, mtime,
+                                                veryfy_source_code)
             else:
                 w = load_workflow_from_template(template_path, inject,
                                                 base_path, target_path,
-                                                package, mtime)
+                                                package, mtime,
+                                                veryfy_source_code)
         else:
             raise ValueError(f"Invalid workflow: {workflow}")
         w.__workflow_id__ = str(Path(w.__file__).relative_to(base_path))
@@ -450,7 +469,8 @@ def load_workflow(workflow: str | tuple[str, dict],
             w = SetConfigWorkflow(key)
             w.__workflow_id__ = workflow
         else:
-            w = load_workflow_from_file(workflow, base_path, package)
+            w = load_workflow_from_file(workflow, base_path, package,
+                                        veryfy_source_code)
             w.__workflow_id__ = str(Path(w.__file__).relative_to(base_path))
     else:
         raise TypeError(f"Invalid workflow: {workflow}")
@@ -458,11 +478,15 @@ def load_workflow(workflow: str | tuple[str, dict],
     return w
 
 
-def _load_workflow_list(workflow, lst, code_path):
+def _load_workflow_list(workflow, lst, code_path, veryfy_source_code):
     ret = []
     for i, n in enumerate(lst):
         try:
-            ret.append(load_workflow(n, code_path, mtime=workflow.__mtime__))
+            ret.append(
+                load_workflow(n,
+                              code_path,
+                              mtime=workflow.__mtime__,
+                              veryfy_source_code=veryfy_source_code))
         except TemplateKeyError as e:
             msg, *_ = e.args
             e.args = (
@@ -471,16 +495,18 @@ def _load_workflow_list(workflow, lst, code_path):
     return ret
 
 
-def get_dependents(workflow: WorkflowType,
-                   code_path: str | Path) -> list[WorkflowType]:
+def get_dependents(workflow: WorkflowType, code_path: str | Path,
+                   veryfy_source_code: bool) -> list[WorkflowType]:
     if callable(getattr(workflow, 'depends', None)):
         if not can_call_without_args(workflow.depends):
             raise AttributeError(
                 f'Workflow {workflow.__workflow_id__} "depends" function should not have any parameters'
             )
-        return _load_workflow_list(workflow, workflow.depends(), code_path)
+        return _load_workflow_list(workflow, workflow.depends(), code_path,
+                                   veryfy_source_code)
     elif isinstance(getattr(workflow, 'depends', None), (list, tuple)):
-        return _load_workflow_list(workflow, workflow.depends, code_path)
+        return _load_workflow_list(workflow, workflow.depends, code_path,
+                                   veryfy_source_code)
     elif getattr(workflow, 'depends', None) is None:
         return []
     else:
@@ -489,16 +515,18 @@ def get_dependents(workflow: WorkflowType,
         )
 
 
-def get_entries(workflow: WorkflowType,
-                code_path: str | Path) -> list[WorkflowType]:
+def get_entries(workflow: WorkflowType, code_path: str | Path,
+                veryfy_source_code: bool) -> list[WorkflowType]:
     if callable(getattr(workflow, 'entries', None)):
         if not can_call_without_args(workflow.entries):
             raise AttributeError(
                 f'Workflow {workflow.__workflow_id__} "entries" function should not have any parameters'
             )
-        return _load_workflow_list(workflow, workflow.entries(), code_path)
+        return _load_workflow_list(workflow, workflow.entries(), code_path,
+                                   veryfy_source_code)
     elif isinstance(getattr(workflow, 'entries', None), (list, tuple)):
-        return _load_workflow_list(workflow, workflow.entries, code_path)
+        return _load_workflow_list(workflow, workflow.entries, code_path,
+                                   veryfy_source_code)
     elif getattr(workflow, 'entries', None) is None:
         return []
     else:
@@ -507,19 +535,28 @@ def get_entries(workflow: WorkflowType,
         )
 
 
-def make_graph(workflow: WorkflowType, graph: dict, code_path: str | Path):
+def make_graph(workflow: WorkflowType,
+               graph: dict,
+               code_path: str | Path,
+               veryfy_source_code: bool = True):
     if workflow.__workflow_id__ in graph:
         return graph
     graph[workflow.__workflow_id__] = []
 
     if hasattr(workflow, 'entries'):
-        for w in get_entries(workflow, code_path):
+        for w in get_entries(workflow, code_path, veryfy_source_code):
             graph[workflow.__workflow_id__].append(w.__workflow_id__)
-            make_graph(w, graph=graph, code_path=code_path)
+            make_graph(w,
+                       graph=graph,
+                       code_path=code_path,
+                       veryfy_source_code=veryfy_source_code)
     elif hasattr(workflow, 'depends'):
-        for w in get_dependents(workflow, code_path):
+        for w in get_dependents(workflow, code_path, veryfy_source_code):
             graph[workflow.__workflow_id__].append(w.__workflow_id__)
-            make_graph(w, graph=graph, code_path=code_path)
+            make_graph(w,
+                       graph=graph,
+                       code_path=code_path,
+                       veryfy_source_code=veryfy_source_code)
     if graph[workflow.__workflow_id__] == []:
         del graph[workflow.__workflow_id__]
 

qulab/executor/schedule.py

@@ -71,7 +71,7 @@ def veryfy_analyzed_report(report: Report, script: str, method: str):
 
 
 def check_state(workflow: WorkflowType, code_path: str | Path,
-                state_path: str | Path) -> bool:
+                state_path: str | Path, veryfy_source_code: bool) -> bool:
     """
     check state should report a pass if and only if the following are satisfied:
     
@@ -110,15 +110,15 @@ def check_state(workflow: WorkflowType, code_path: str | Path,
         logger.debug(
             f'check_state failed: "{workflow.__workflow_id__}" has bad data')
         return False
-    for n in get_dependents(workflow, code_path):
+    for n in get_dependents(workflow, code_path, veryfy_source_code):
         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'
             )
             return False
-    for n in get_dependents(workflow, code_path):
-        if not check_state(n, code_path, state_path):
+    for n in get_dependents(workflow, code_path, veryfy_source_code):
+        if not check_state(n, code_path, state_path, veryfy_source_code):
             logger.debug(
                 f'check_state failed: "{workflow.__workflow_id__}" has bad dependencies'
             )
@@ -126,7 +126,7 @@ def check_state(workflow: WorkflowType, code_path: str | Path,
     return True
 
 
-@logger.catch()
+@logger.catch(reraise=False)
 async def call_plot(node: WorkflowType, report: Report, check=False):
     if hasattr(node, 'plot') and callable(node.plot):
         if inspect.iscoroutinefunction(node.plot):
@@ -361,7 +361,8 @@ async def calibrate(workflow: WorkflowType, state_path: str | Path, plot: bool,
 
 
 async def diagnose(workflow: WorkflowType, code_path: str | Path,
-                   state_path: str | Path, plot: bool, session_id: str):
+                   state_path: str | Path, plot: bool, session_id: str,
+                   veryfy_source_code: bool):
     '''
     Returns: True if node or dependent recalibrated.
     '''
@@ -379,10 +380,17 @@ async def diagnose(workflow: WorkflowType, code_path: str | Path,
     if report.bad_data:
         logger.debug(
             f'"{workflow.__workflow_id__}": Bad data, diagnosing dependents')
-        recalibrated = [
-            await diagnose(n, code_path, state_path, plot, session_id)
-            for n in get_dependents(workflow, code_path)
-        ]
+        recalibrated = []
+        exceptions = []
+        for n in get_dependents(workflow, code_path, veryfy_source_code):
+            try:
+                flag = await diagnose(n, code_path, state_path, plot,
+                                      session_id, veryfy_source_code)
+            except Exception as e:
+                exceptions.append(e)
+            recalibrated.append(flag)
+        if any(exceptions):
+            raise exceptions[0]
     if not any(recalibrated):
         if report.bad_data:
             raise CalibrationFailedError(
@@ -427,28 +435,37 @@ async def maintain(workflow: WorkflowType,
                    session_id: str | None = None,
                    run: bool = False,
                    plot: bool = False,
-                   freeze: bool = False):
+                   freeze: bool = False,
+                   veryfy_source_code: bool = True):
     if session_id is None:
         session_id = uuid.uuid4().hex
     logger.debug(f'run "{workflow.__workflow_id__}"'
                  if run else f'maintain "{workflow.__workflow_id__}"')
     # recursive maintain
-    for n in get_dependents(workflow, code_path):
+    exceptions = []
+    for n in get_dependents(workflow, code_path, veryfy_source_code):
         logger.debug(
             f'maintain "{n.__workflow_id__}" because it is depended by "{workflow.__workflow_id__}"'
         )
-        await maintain(n,
-                       code_path,
-                       state_path,
-                       session_id,
-                       run=False,
-                       plot=plot,
-                       freeze=freeze)
+        try:
+            await maintain(n,
+                           code_path,
+                           state_path,
+                           session_id,
+                           run=False,
+                           plot=plot,
+                           freeze=freeze,
+                           veryfy_source_code=veryfy_source_code)
+        except Exception as e:
+            exceptions.append(e)
     else:
         logger.debug(
             f'"{workflow.__workflow_id__}": All dependents maintained')
+    if any(exceptions):
+        raise exceptions[0]
     # check_state
-    if check_state(workflow, code_path, state_path) and not run:
+    if check_state(workflow, code_path, state_path,
+                   veryfy_source_code) and not run:
         logger.debug(
             f'"{workflow.__workflow_id__}": In spec, no need to maintain')
         return
@@ -462,14 +479,21 @@ async def maintain(workflow: WorkflowType,
     elif report.bad_data:
         logger.debug(
             f'"{workflow.__workflow_id__}": Bad data, diagnosing dependents')
-        for n in get_dependents(workflow, code_path):
+        exceptions = []
+        for n in get_dependents(workflow, code_path, veryfy_source_code):
             logger.debug(
                 f'diagnose "{n.__workflow_id__}" because of "{workflow.__workflow_id__}" bad data'
             )
-            await diagnose(n, code_path, state_path, plot, session_id)
+            try:
+                await diagnose(n, code_path, state_path, plot, session_id,
+                               veryfy_source_code)
+            except Exception as e:
+                exceptions.append(e)
         else:
             logger.debug(
                 f'"{workflow.__workflow_id__}": All dependents diagnosed')
+        if any(exceptions):
+            raise exceptions[0]
     # calibrate
     logger.debug(f'recalibrate "{workflow.__workflow_id__}"')
     report = await calibrate(workflow, state_path, plot, session_id)

qulab/executor/utils.py

@@ -33,11 +33,11 @@ def dependent_tree(node: str, code_path: str | Path) -> dict[str, list[str]]:
 
 
 def workflow_template(workflow: str, deps: list[str]) -> str:
-    return f"""def VAR(s): pass  # 没有实际作用，只是用来抑制编辑器的警告。
-
+    return f"""
 import numpy as np
 from loguru import logger
 
+from qulab import VAR
 from qulab.typing import Report
 
 
@@ -48,7 +48,7 @@ def depends():
     return {deps!r}
 
 
-def calibrate():
+async def calibrate():
     logger.info(f"running {workflow} ...")
 
     # calibrate 是一个完整的校准实验，如power Rabi，Ramsey等。
@@ -64,7 +64,7 @@ def calibrate():
     return x, y
 
 
-def analyze(report: Report, history: Report | None = None) -> Report:
+async def analyze(report: Report, history: Report | None = None) -> Report:
     \"\"\"
     分析校准结果。
 
@@ -95,7 +95,7 @@ def analyze(report: Report, history: Report | None = None) -> Report:
     return report
 
 
-def check():
+async def check():
     logger.info(f"checking {workflow} ...")
 
     # check 是一个快速检查实验，用于检查校准是否过时。
@@ -112,7 +112,7 @@ def check():
     return x, y
 
 
-def check_analyze(report: Report, history: Report | None = None) -> Report:
+async def check_analyze(report: Report, history: Report | None = None) -> Report:
     \"\"\"
     分析检查结果。
 
@@ -136,7 +136,7 @@ def check_analyze(report: Report, history: Report | None = None) -> Report:
     return report
 
 
-def oracle(report: Report,
+async def oracle(report: Report,
            history: Report | None = None,
            system_state: dict[str:str] | None = None) -> Report:
     \"\"\"

qulab/sys/device/basedevice.py

@@ -1,3 +1,4 @@
+import copy
 import itertools
 import logging
 import re
@@ -127,7 +128,8 @@ class BaseDevice(metaclass=DeviceMeta):
     __log__ = None
 
     def __init__(self, address: str = None, **options):
-        self._status = {}
+        self._state = {}
+        self._status = "NOT CONNECTED"
         self.address = address
         self.options = options
 
@@ -144,28 +146,40 @@ class BaseDevice(metaclass=DeviceMeta):
                 f"{self.__class__.__module__}.{self.__class__.__name__}")
         return self.__log__
 
+    @property
+    def state(self):
+        return copy.deepcopy(self._state)
+    
+    def get_state(self, key: str, default=None) -> Any:
+        return self._state.get(key, default)
+
+    @property
+    def status(self):
+        return self._status
+
     def open(self) -> None:
-        pass
+        self._status = "CONNECTED"
 
     def close(self) -> None:
-        pass
+        self._status = "NOT CONNECTED"
+        self._state.clear()
 
     def reset(self) -> None:
-        self._status.clear()
+        self._state.clear()
 
     def get(self, key: str, default: Any = None) -> Any:
         self.log.info(f'Get {key!r}')
         if key in self.__get_actions__:
             result = self.__get_actions__[key](self)
-            self._status[key] = result
+            self._state[key] = result
             return result
         else:
-            return self._status.get(key, default)
+            return self._state.get(key, default)
 
     def set(self, key: str, value: Any = None) -> None:
         self.log.info(f'Set {key!r} = {value!r}')
         self.__set_actions__[key](self, value)
-        self._status[key] = value
+        self._state[key] = value
 
     def post(self, key: str, value: Any = None) -> Any:
         self.log.info(f'Post {key!r} = {value!r}')
@@ -174,7 +188,7 @@ class BaseDevice(metaclass=DeviceMeta):
     def delete(self, key: str) -> None:
         self.log.info(f'Delete {key!r}')
         self.__delete_actions__[key](self)
-        del self._status[key]
+        del self._state[key]
 
     def __repr__(self) -> str:
         return f'{self.__class__.__name__}({self.address!r})'
@@ -193,8 +207,10 @@ class VisaDevice(BaseDevice):
             rm = pyvisa.ResourceManager()
         self.resource = rm.open_resource(self.address, **kwds)
         self.errors = []
+        super().open()
 
     def close(self) -> None:
+        super().close()
         self.resource.close()
 
     def reset(self) -> None:

qulab/sys/drivers/FakeInstrument.py

@@ -35,7 +35,7 @@ class Device(BaseDevice):
 
     # @get('${channel}.Vpp', channel=exclude(['M1', 'M2']))
     # def get_voltage(self, channel: str, default=0.0) -> float:
-    #     return self._status.get(f'{channel}.Vpp', default)
+    #     return self._state.get(f'{channel}.Vpp', default)
 
     @set('${channel}.Offset', channel=exclude(['M1', 'M2']))
     def set_offset(
@@ -47,7 +47,7 @@ class Device(BaseDevice):
 
     # @get('${channel}.Offset', channel=exclude(['M1', 'M2']))
     # def get_offset(self, channel: str, default=0.0) -> float:
-    #     return self._status.get(f'{channel}.Offset', default)
+    #     return self._state.get(f'{channel}.Offset', default)
 
     @set('${channel}.Waveform', channel=exclude(['M1', 'M2']))
     def set_waveform(self, value, channel: str) -> None:
@@ -55,7 +55,7 @@ class Device(BaseDevice):
 
     # @get('${channel}.Waveform', channel=exclude(['M1', 'M2']))
     # def get_waveform(self, channel: str, default=None) -> str:
-    #     return self._status.get(f'{channel}.Waveform', default)
+    #     return self._state.get(f'{channel}.Waveform', default)
 
     @set('${channel}.Size', channel=['M1', 'M2'])
     def set_size(self, value, channel: str) -> None:
@@ -63,6 +63,6 @@ class Device(BaseDevice):
 
     @get('${channel}.Trace', channel=['M1', 'M2'])
     def get_random_data(self, channel: str) -> np.ndarray:
-        size = self._status.get(f'{channel}.Size', 1024)
-        shots = self._status.get(f'{channel}.Shots', 128)
+        size = self._state.get(f'{channel}.Size', 1024)
+        shots = self._state.get(f'{channel}.Shots', 128)
         return np.random.randn(shots, size)

qulab/version.py

@@ -1 +1 @@
-__version__ = "2.10.0"
+__version__ = "2.10.2"

{qulab-2.10.0.dist-info → qulab-2.10.2.dist-info}/METADATA

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

{qulab-2.10.0.dist-info → qulab-2.10.2.dist-info}/RECORD

@@ -1,23 +1,23 @@
 qulab/__init__.py,sha256=ulapyzt9DsDgT68EEbzuhniofHb512pNTFc-Sxfrr8Y,375
 qulab/__main__.py,sha256=FL4YsGZL1jEtmcPc5WbleArzhOHLMsWl7OH3O-1d1ss,72
 qulab/dicttree.py,sha256=ZoSJVWK4VMqfzj42gPb_n5RqLlM6K1Me0WmLIfLEYf8,14195
-qulab/fun.cp311-win_amd64.pyd,sha256=Lfoet9BEv6lyx3lGiarjNJ-mlKcIywvKESmWYNaPn_8,31744
+qulab/fun.cp311-win_amd64.pyd,sha256=aOPP4p3-rFr4abiAORysVYu_lwKV4AvueFffjzHzQfA,31744
 qulab/typing.py,sha256=PRtwbCHWY2ROKK8GHq4Bo8llXrIGo6xC73DrQf7S9os,71
 qulab/utils.py,sha256=65N2Xj7kqRsQ4epoLNY6tL-i5ts6Wk8YuJYee3Te6zI,3077
-qulab/version.py,sha256=-wrxKlVMUOYQC2baw-827pV-q4STQnQkmi5VCiGpO64,22
+qulab/version.py,sha256=UINbgWwinYgAg8jG5YWakGzXmyfjSZZfKyqiqfovSAk,22
 qulab/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/cli/commands.py,sha256=ZTs32yQjvwPIsFjXYWNr4KqEvly0NISIqyh--96qCAY,627
 qulab/cli/config.py,sha256=A3UnyaRtiofpokyzYkJnUdwzcsYX7H-xZvBVduIOSdg,5617
 qulab/cli/decorators.py,sha256=UmJab1o-XH-8DVS_LZFGY2SPjyVgZ1QrJwkauTZDUik,626
 qulab/executor/__init__.py,sha256=LosPzOMaljSZY1thy_Fxtbrgq7uubJszMABEB7oM7tU,101
 qulab/executor/analyze.py,sha256=VoSthE2RTarY6Wj3QFKh4FqReMYL7djSAyuitgHs5K0,5837
-qulab/executor/cli.py,sha256=JhaOvMfLHOFe8HdQhGeqU3Lj3z0mJXLXJhzIwmAsaso,12251
-qulab/executor/load.py,sha256=6QLlATu2KyGY2nrWLFTVxDE4DwoCXx3WNx72QR_LZB0,18715
-qulab/executor/schedule.py,sha256=PmNRvs41DXKC2teHj5XGblpUEKLrsZpgPqk2K-opA-g,20009
+qulab/executor/cli.py,sha256=wfz2zl0-DeMMHvF2kqTzT8MGA-K2kIfZjRAByYsh33A,14052
+qulab/executor/load.py,sha256=0-EtO4dkP6jB1vsgQlniv-OtPH1AZLjbtuvaWHsgbPs,20335
+qulab/executor/schedule.py,sha256=GhY4-kkNKF_EQ45Gwhd358jkEqweSJGWcuKoWGRM2wY,21067
 qulab/executor/storage.py,sha256=8K73KGLAVgchJdtd4rKHXkr1CQOJORWH-Gi57w8IYsw,21081
 qulab/executor/template.py,sha256=dKQM3IlADdTi9qp0fnOYjyycRNEl7KeSCBZhwbmP8bQ,10828
 qulab/executor/transform.py,sha256=rk4CLIKVjGRaFzi5FVSgadUxAKKVLSopEHZCaAzDwDg,3435
-qulab/executor/utils.py,sha256=S254JDTKVA4Fnu9lslNBos6vEssLWn8zbMjhmLP-Gi8,6434
+qulab/executor/utils.py,sha256=3OLRMBJu-1t78BeuZs4fv4jioEXnRNygaPnSoibzfgs,6405
 qulab/monitor/__init__.py,sha256=xEVDkJF8issrsDeLqQmDsvtRmrf-UiViFcGTWuzdlFU,43
 qulab/monitor/__main__.py,sha256=k2H1H5Zf9LLXTDLISJkbikLH-z0f1e5i5i6wXXYPOrE,105
 qulab/monitor/config.py,sha256=y_5StMkdrbZO1ziyKBrvIkB7Jclp9RCPK1QbsOhCxnY,785
@@ -62,10 +62,10 @@ qulab/sys/chat.py,sha256=t7wSlREOQ_Ke0pO9bfpkik9wY1qeiTbRF1dial9IbII,23137
 qulab/sys/ipy_events.py,sha256=rGjsApv58_Gwd_TH6ecPnyXK34_ZYZsaX8tk32ozLGY,3014
 qulab/sys/progress.py,sha256=2iYskzRdOC2EM4wtbzm0u1kovjGrF_A0W1kCxbftyzE,5540
 qulab/sys/device/__init__.py,sha256=ZZxPJ9_MHModvghQoZOSWjIdeo3vhg2TJETDdrwQvkU,152
-qulab/sys/device/basedevice.py,sha256=lTPv5geL556h9Hfp9zqJQ5miuX8CK2PBHJ9xY1ix4g4,7017
+qulab/sys/device/basedevice.py,sha256=mdKUzu0TpHIVMVQ4y7eADtlvGjFAjO-_NSEucLyVv3o,7450
 qulab/sys/device/loader.py,sha256=RyUoykxGyfn-k22NWo-B06_AK_TMH8to4FzSkODLJHM,2583
 qulab/sys/device/utils.py,sha256=5uqGOcaZlubCIw7gsknpB-tiFQyq8y6ebQxHcouQGUs,2393
-qulab/sys/drivers/FakeInstrument.py,sha256=xBz-uuOivB1mKeJEfJJMEDTZujtpwDPJRWiIaoam0KM,2479
+qulab/sys/drivers/FakeInstrument.py,sha256=w5ItiveUppBoH2egZtfS6u7_heORA98iUdYeMjQkx8A,2474
 qulab/sys/drivers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/sys/net/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/sys/net/bencoder.py,sha256=tsMjTG-E_EQokfWrZgJvxO3dTGaM6NOVzPPKsify23A,5164
@@ -99,9 +99,9 @@ qulab/visualization/plot_seq.py,sha256=Uo1-dB1YE9IN_A9tuaOs9ZG3S5dKDQ_l98iD2Wbxp
 qulab/visualization/qdat.py,sha256=HubXFu4nfcA7iUzghJGle1C86G6221hicLR0b-GqhKQ,5887
 qulab/visualization/rot3d.py,sha256=jGHJcqj1lEWBUV-W4GUGONGacqjrYvuFoFCwPse5h1Y,757
 qulab/visualization/widgets.py,sha256=HcYwdhDtLreJiYaZuN3LfofjJmZcLwjMfP5aasebgDo,3266
-qulab-2.10.0.dist-info/licenses/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
-qulab-2.10.0.dist-info/METADATA,sha256=Ub4cLijllfpKnMHVQaPb2yE8sMBuq7zFv6XksmaVsEQ,3860
-qulab-2.10.0.dist-info/WHEEL,sha256=_ZWIY2n7n6SpiuIFl1-RvcMp4Ty36T57FKf-7NzqZHM,101
-qulab-2.10.0.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
-qulab-2.10.0.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-qulab-2.10.0.dist-info/RECORD,,
+qulab-2.10.2.dist-info/licenses/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
+qulab-2.10.2.dist-info/METADATA,sha256=BbVR3fNk1YWnGToqB6gx0PpS4eaKZU9ht9en-2R60ws,3860
+qulab-2.10.2.dist-info/WHEEL,sha256=_ZWIY2n7n6SpiuIFl1-RvcMp4Ty36T57FKf-7NzqZHM,101
+qulab-2.10.2.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
+qulab-2.10.2.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+qulab-2.10.2.dist-info/RECORD,,