QuLab 2.10.1__tar.gz → 2.10.3__tar.gz

{qulab-2.10.1 → qulab-2.10.3}/PKG-INFO

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

{qulab-2.10.1 → qulab-2.10.3}/QuLab.egg-info/PKG-INFO

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

{qulab-2.10.1 → qulab-2.10.3}/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}"
@@ -164,10 +169,26 @@ def get(key, api):
               help='Do not run dependents.')
 @click.option('--retry', '-r', default=1, type=int, help='Retry times.')
 @click.option('--freeze', is_flag=True, help='Freeze the config table.')
+@click.option('--fail-fast',
+              '-f',
+              is_flag=True,
+              help='Fail immediately on first error.')
+@click.option('--veryfy-source-code',
+              is_flag=True,
+              help='Veryfy the source code.')
 @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,
+              fail_fast,
+              veryfy_source_code=True):
     """
     Run a workflow.
 
@@ -198,41 +219,73 @@ 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:
+                            if fail_fast:
+                                raise 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,
+                                fail_fast=fail_fast,
+                                veryfy_source_code=veryfy_source_code,
+                            )
+                        except Exception as e:
+                            if fail_fast:
+                                raise 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,
+                        fail_fast=fail_fast,
+                        veryfy_source_code=veryfy_source_code,
+                    )
             break
         except CalibrationFailedError as e:
             if i == retry - 1:
@@ -245,10 +298,24 @@ async def run(workflow, code, data, api, plot, no_dependents, retry, freeze):
 @click.argument('workflow')
 @click.option('--retry', '-r', default=1, type=int, help='Retry times.')
 @click.option('--plot', '-p', is_flag=True, help='Plot the report.')
+@click.option('--fail-fast',
+              '-f',
+              is_flag=True,
+              help='Fail immediately on first error.')
+@click.option('--veryfy-source-code',
+              is_flag=True,
+              help='Veryfy the source code.')
 @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,
+                   fail_fast,
+                   veryfy_source_code=True):
     """
     Maintain a workflow.
 
@@ -275,26 +342,43 @@ 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,
+                            fail_fast=fail_fast,
+                            veryfy_source_code=veryfy_source_code,
+                        )
+                    except Exception as e:
+                        if fail_fast:
+                            raise 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,
+                    fail_fast=fail_fast,
+                    veryfy_source_code=veryfy_source_code,
+                )
             break
         except CalibrationFailedError as e:
             if i == retry - 1:

{qulab-2.10.1 → qulab-2.10.3}/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
@@ -305,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():
@@ -319,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__'):
@@ -327,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
 
@@ -380,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)
 
@@ -413,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)
@@ -425,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))
@@ -454,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}")
@@ -462,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 = (
@@ -475,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:
@@ -493,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:
@@ -511,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-2.10.1 → qulab-2.10.3}/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,
+                   fail_fast: bool, veryfy_source_code: bool):
     '''
     Returns: True if node or dependent recalibrated.
     '''
@@ -379,10 +380,20 @@ 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, fail_fast,
+                                      veryfy_source_code)
+            except Exception as e:
+                if fail_fast:
+                    raise 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 +438,41 @@ async def maintain(workflow: WorkflowType,
                    session_id: str | None = None,
                    run: bool = False,
                    plot: bool = False,
-                   freeze: bool = False):
+                   freeze: bool = False,
+                   fail_fast: 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,
+                           fail_fast=fail_fast,
+                           veryfy_source_code=veryfy_source_code)
+        except Exception as e:
+            if fail_fast:
+                raise 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 +486,23 @@ 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,
+                               fail_fast, veryfy_source_code)
+            except Exception as e:
+                if fail_fast:
+                    raise 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-2.10.1 → qulab-2.10.3}/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-2.10.1 → qulab-2.10.3}/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-2.10.1 → qulab-2.10.3}/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-2.10.3/qulab/version.py

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

qulab-2.10.1/qulab/version.py

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