QuLab 2.7.7__cp310-cp310-win_amd64.whl → 2.7.10__cp310-cp310-win_amd64.whl

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

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

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

@@ -1,19 +1,19 @@
 qulab/__init__.py,sha256=RZme5maBSMZpP6ckXymqZpo2sRYttwEpTYCIzIvys1c,292
 qulab/__main__.py,sha256=FL4YsGZL1jEtmcPc5WbleArzhOHLMsWl7OH3O-1d1ss,72
 qulab/dicttree.py,sha256=ZoSJVWK4VMqfzj42gPb_n5RqLlM6K1Me0WmLIfLEYf8,14195
-qulab/fun.cp310-win_amd64.pyd,sha256=vauOCBvFFrTfjSoJBrubXMCNetihsicaB3Ff1I57_1E,31232
+qulab/fun.cp310-win_amd64.pyd,sha256=y0aR1tHQkJeC9hmGmZpfrLsZQ2V_xhoGnFZ_V9MOSWU,31232
 qulab/typing.py,sha256=PRtwbCHWY2ROKK8GHq4Bo8llXrIGo6xC73DrQf7S9os,71
 qulab/utils.py,sha256=UyZNPIyvis5t2MJBkXXLO5EmYP3mQZbt87zmYAHgoyk,1291
-qulab/version.py,sha256=TXxZaBvn1Y_BQ2YYBZ0iedwKmA3iOfYiZehFXuAoky0,21
+qulab/version.py,sha256=jdPSCkDOwzHQzdidl89buWuyX5dorFZluLWAvXtMdIU,22
 qulab/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/cli/commands.py,sha256=6xd2eYw32k1NmfAuYSu__1kaP12Oz1QVqwbkYXdWno4,588
 qulab/cli/config.py,sha256=tNmH4ggdgrFqcQa2WZKLpidiYTg95_UnT0paDJ4fi4c,3204
 qulab/executor/__init__.py,sha256=LosPzOMaljSZY1thy_Fxtbrgq7uubJszMABEB7oM7tU,101
 qulab/executor/cli.py,sha256=gGka2M6xccfM8facsIJ2qZ1y2Yx8C4BRhc1JG6nK9mo,8932
 qulab/executor/load.py,sha256=4FY_SwumLDUewC265v4j_ZGGpfYOgH4c8PtglYcWpBw,18077
-qulab/executor/schedule.py,sha256=DHQ5dI5YX8_frWplOoLEb9htcfM5-mikiSBNSPWT1io,16725
-qulab/executor/storage.py,sha256=sBD-aNvj29l5HtoTpk_627qarZkPn33F-hcc80AuF6k,11079
-qulab/executor/transform.py,sha256=s0kxWQx8Sr9pMIQke1BLNM6KqrSogAkjB6Zkapl8YSU,2189
+qulab/executor/schedule.py,sha256=S8zRdkM2_I9-EqMUCEGI9boe3sfc68Gn5NRK057ShAw,17997
+qulab/executor/storage.py,sha256=gI6g28BmKKEZ_Pl-hFwvpiOj3mF8Su-yjj3hfMXs1VY,11630
+qulab/executor/transform.py,sha256=4DyGXv1Iw36cCPqbqXlsn0Lw6gFjQpp_6Hcta50YQxU,2181
 qulab/executor/utils.py,sha256=cF6-2jlvlHyTjNHdxXKG04Fjfm3_3wfDQAF1G8DQphk,5686
 qulab/monitor/__init__.py,sha256=xEVDkJF8issrsDeLqQmDsvtRmrf-UiViFcGTWuzdlFU,43
 qulab/monitor/__main__.py,sha256=k2H1H5Zf9LLXTDLISJkbikLH-z0f1e5i5i6wXXYPOrE,105
@@ -94,9 +94,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.7.7.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
-QuLab-2.7.7.dist-info/METADATA,sha256=wLdPCOG28AtjkgODhWfbkl1uLP1i3G9Rj-feGwWtHKM,3803
-QuLab-2.7.7.dist-info/WHEEL,sha256=rzGfZgUcGeKSgIHGYMuqg4xE4VPHxnaldXH6BG0zjVk,101
-QuLab-2.7.7.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
-QuLab-2.7.7.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-QuLab-2.7.7.dist-info/RECORD,,
+QuLab-2.7.10.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
+QuLab-2.7.10.dist-info/METADATA,sha256=AfZd0GQ9mjSrXkCkGbvWEHs7uJ_jt7QKh4T6wZtZ5ws,3804
+QuLab-2.7.10.dist-info/WHEEL,sha256=rzGfZgUcGeKSgIHGYMuqg4xE4VPHxnaldXH6BG0zjVk,101
+QuLab-2.7.10.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
+QuLab-2.7.10.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+QuLab-2.7.10.dist-info/RECORD,,

qulab/executor/schedule.py

@@ -7,8 +7,8 @@ from pathlib import Path
 from loguru import logger
 
 from .load import WorkflowType, get_dependents
-from .storage import (Report, find_report, get_heads, renew_report,
-                      revoke_report, save_report)
+from .storage import (Report, find_report, get_head, get_heads, renew_report,
+                      revoke_report, save_item, save_report)
 from .transform import current_config, obey_the_oracle, update_parameters
 
 __session_id = None
@@ -69,6 +69,16 @@ def veryfy_analyzed_report(report: Report, script: str, method: str):
         )
 
 
+def get_source(workflow: WorkflowType, code_path: str | Path) -> str:
+    if isinstance(code_path, str):
+        code_path = Path(code_path)
+    try:
+        with open(code_path / workflow.__workflow_id__, 'r') as f:
+            return f.read()
+    except:
+        return ''
+
+
 def check_state(workflow: WorkflowType, code_path: str | Path,
                 state_path: str | Path) -> bool:
     """
@@ -91,6 +101,11 @@ def check_state(workflow: WorkflowType, code_path: str | Path,
             f'check_state: "{workflow.__workflow_id__}" has custom check_state method'
         )
         return workflow.check_state(report)
+    if datetime.fromtimestamp(workflow.__mtime__) > report.checked_time:
+        logger.debug(
+            f'check_state failed: "{workflow.__workflow_id__}" has been modified after last calibration'
+        )
+        return False
     if workflow.__timeout__ is not None and datetime.now(
     ) > report.checked_time + timedelta(seconds=workflow.__timeout__):
         logger.debug(
@@ -120,42 +135,6 @@ def check_state(workflow: WorkflowType, code_path: str | Path,
     return True
 
 
-def call_analyzer(node: WorkflowType,
-                  report: Report,
-                  history: Report | None,
-                  check=False,
-                  plot=False) -> Report:
-    if check:
-        report = node.check_analyze(report, history=history)
-        veryfy_analyzed_report(report, node.__workflow_id__, "check_analyze")
-        report.fully_calibrated = False
-    else:
-        report = node.analyze(report, history=history)
-        veryfy_analyzed_report(report, node.__workflow_id__, "analyze")
-        if hasattr(node, 'oracle') and callable(node.oracle):
-            logger.debug(
-                f'"{node.__workflow_id__}" has oracle method, calling ...')
-            try:
-                report = node.oracle(report,
-                                     history=history,
-                                     system_state=get_heads(report.base_path))
-            except Exception as e:
-                logger.exception(e)
-                report.oracle = {}
-            if not isinstance(report, Report):
-                raise TypeError(
-                    f'"{node.__workflow_id__}" : function "oracle" must return a Report object'
-                )
-            if not is_pickleable(report.oracle):
-                raise TypeError(
-                    f'"{node.__workflow_id__}" : function "oracle" return not pickleable data'
-                )
-        report.fully_calibrated = True
-        if plot:
-            call_plot(node, report)
-    return report
-
-
 @logger.catch()
 def call_plot(node: WorkflowType, report: Report, check=False):
     if hasattr(node, 'plot') and callable(node.plot):
@@ -177,12 +156,13 @@ def call_check(workflow: WorkflowType, session_id: str, state_path: Path):
                     data=data,
                     config_path=current_config(state_path),
                     base_path=state_path,
-                    heads=get_heads(state_path))
+                    heads=get_heads(state_path),
+                    previous_path=get_head(workflow.__workflow_id__,
+                                           state_path),
+                    script_path=save_item(get_source(workflow, state_path),
+                                          state_path))
 
-    save_report(workflow.__workflow_id__,
-                report,
-                state_path,
-                refresh_heads=False)
+    save_report(workflow.__workflow_id__, report, state_path)
 
     set_cache(session_id, (workflow, 'check'), report)
     return report
@@ -203,7 +183,11 @@ def call_calibrate(workflow: WorkflowType, session_id: str, state_path: Path):
                     data=data,
                     config_path=current_config(state_path),
                     base_path=state_path,
-                    heads=get_heads(state_path))
+                    heads=get_heads(state_path),
+                    previous_path=get_head(workflow.__workflow_id__,
+                                           state_path),
+                    script_path=save_item(get_source(workflow, state_path),
+                                          state_path))
 
     save_report(workflow.__workflow_id__, report, state_path)
 
@@ -211,8 +195,66 @@ def call_calibrate(workflow: WorkflowType, session_id: str, state_path: Path):
     return report
 
 
-def check_data(workflow: WorkflowType, code_path: str | Path,
-               state_path: str | Path, plot: bool, session_id: str) -> Report:
+def call_check_analyzer(node: WorkflowType,
+                        report: Report,
+                        history: Report | None,
+                        state_path: Path,
+                        plot=False) -> Report:
+    report = node.check_analyze(report, history=history)
+    veryfy_analyzed_report(report, node.__workflow_id__, "check_analyze")
+    report.fully_calibrated = False
+    if report.in_spec:
+        logger.debug(
+            f'"{node.__workflow_id__}": checked in spec, renewing report')
+        if report.previous is not None:
+            renew_report(node.__workflow_id__, report.previous, state_path)
+        else:
+            renew_report(node.__workflow_id__, report, state_path)
+    else:
+        logger.debug(
+            f'"{node.__workflow_id__}": checked out of spec, revoking report')
+        if report.previous is not None:
+            revoke_report(node.__workflow_id__, report.previous, state_path)
+        else:
+            revoke_report(node.__workflow_id__, report, state_path)
+    return report
+
+
+def call_analyzer(node: WorkflowType,
+                  report: Report,
+                  history: Report | None,
+                  state_path: Path,
+                  plot=False) -> Report:
+
+    report = node.analyze(report, history=history)
+    veryfy_analyzed_report(report, node.__workflow_id__, "analyze")
+    if hasattr(node, 'oracle') and callable(node.oracle):
+        logger.debug(
+            f'"{node.__workflow_id__}" has oracle method, calling ...')
+        try:
+            report = node.oracle(report,
+                                 history=history,
+                                 system_state=get_heads(report.base_path))
+        except Exception as e:
+            logger.exception(e)
+            report.oracle = {}
+        if not isinstance(report, Report):
+            raise TypeError(
+                f'"{node.__workflow_id__}" : function "oracle" must return a Report object'
+            )
+        if not is_pickleable(report.oracle):
+            raise TypeError(
+                f'"{node.__workflow_id__}" : function "oracle" return not pickleable data'
+            )
+    report.fully_calibrated = True
+    save_report(node.__workflow_id__, report, state_path, overwrite=True)
+    if plot:
+        call_plot(node, report)
+    return report
+
+
+def check_data(workflow: WorkflowType, state_path: str | Path, plot: bool,
+               session_id: str) -> Report:
     """
     check data answers two questions:
     Is the parameter associated with this cal in spec,
@@ -225,7 +267,11 @@ def check_data(workflow: WorkflowType, code_path: str | Path,
         report = Report(workflow=workflow.__workflow_id__,
                         config_path=current_config(state_path),
                         base_path=state_path,
-                        heads=get_heads(state_path))
+                        heads=get_heads(state_path),
+                        previous_path=get_head(workflow.__workflow_id__,
+                                               state_path),
+                        script_path=save_item(get_source(workflow, state_path),
+                                              state_path))
         report.in_spec = False
         report.bad_data = False
         return report
@@ -250,21 +296,11 @@ def check_data(workflow: WorkflowType, code_path: str | Path,
         report = call_check(workflow, session_id, state_path)
 
         logger.debug(f'Checked "{workflow.__workflow_id__}" !')
-        report = call_analyzer(workflow,
-                               report,
-                               history,
-                               check=True,
-                               plot=plot)
-        if report.in_spec:
-            logger.debug(
-                f'"{workflow.__workflow_id__}": checked in spec, renewing report'
-            )
-            renew_report(workflow.__workflow_id__, report, state_path)
-        else:
-            logger.debug(
-                f'"{workflow.__workflow_id__}": checked out of spec, revoking report'
-            )
-            revoke_report(workflow.__workflow_id__, report, state_path)
+        report = call_check_analyzer(workflow,
+                                     report,
+                                     history,
+                                     state_path,
+                                     plot=plot)
     else:
         logger.debug(
             f'Checking "{workflow.__workflow_id__}" with "calibrate" method ...'
@@ -276,17 +312,13 @@ def check_data(workflow: WorkflowType, code_path: str | Path,
         report = call_analyzer(workflow,
                                report,
                                history,
-                               check=False,
+                               state_path,
                                plot=plot)
-        save_report(workflow.__workflow_id__,
-                    report,
-                    state_path,
-                    overwrite=True)
     return report
 
 
-def calibrate(workflow: WorkflowType, code_path: str | Path,
-              state_path: str | Path, plot: bool, session_id: str) -> Report:
+def calibrate(workflow: WorkflowType, 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__}" ...')
@@ -295,9 +327,7 @@ def calibrate(workflow: WorkflowType, code_path: str | Path,
 
     logger.debug(f'Calibrated "{workflow.__workflow_id__}" !')
 
-    report = call_analyzer(workflow, report, history, check=False, plot=plot)
-
-    save_report(workflow.__workflow_id__, report, state_path, overwrite=True)
+    report = call_analyzer(workflow, report, history, state_path, plot=plot)
     return report
 
 
@@ -308,7 +338,7 @@ def diagnose(workflow: WorkflowType, code_path: str | Path,
     '''
     logger.debug(f'diagnose "{workflow.__workflow_id__}"')
     # check_data
-    report = check_data(workflow, code_path, state_path, plot, session_id)
+    report = check_data(workflow, state_path, plot, session_id)
     # in spec case
     if report.in_spec:
         logger.debug(
@@ -350,7 +380,7 @@ def diagnose(workflow: WorkflowType, code_path: str | Path,
     else:
         logger.error(f'Never reach: recalibrate "{workflow.__workflow_id__}"')
 
-    report = calibrate(workflow, code_path, state_path, plot, session_id)
+    report = calibrate(workflow, state_path, plot, session_id)
     if report.bad_data or not report.in_spec:
         obey_the_oracle(report, state_path)
         raise CalibrationFailedError(
@@ -393,7 +423,7 @@ def maintain(workflow: WorkflowType,
             f'"{workflow.__workflow_id__}": In spec, no need to maintain')
         return
     # check_data
-    report = check_data(workflow, code_path, state_path, plot, session_id)
+    report = check_data(workflow, state_path, plot, session_id)
     if report.in_spec:
         if not run:
             logger.debug(
@@ -412,7 +442,7 @@ def maintain(workflow: WorkflowType,
                 f'"{workflow.__workflow_id__}": All dependents diagnosed')
     # calibrate
     logger.debug(f'recalibrate "{workflow.__workflow_id__}"')
-    report = calibrate(workflow, code_path, state_path, plot, session_id)
+    report = calibrate(workflow, state_path, plot, session_id)
     if report.bad_data or not report.in_spec:
         if not freeze:
             obey_the_oracle(report, state_path)
@@ -432,11 +462,7 @@ def run(workflow: WorkflowType,
         freeze: bool = False):
     session_id = uuid.uuid4().hex
     logger.debug(f'run "{workflow.__workflow_id__}" without dependences.')
-    report = calibrate(workflow,
-                       code_path,
-                       state_path,
-                       plot,
-                       session_id=session_id)
+    report = calibrate(workflow, state_path, plot, session_id=session_id)
     if report.bad_data or not report.in_spec:
         if not freeze:
             obey_the_oracle(report, state_path)

qulab/executor/storage.py

@@ -34,6 +34,7 @@ class Report():
     base_path: Path | None = field(default=None, repr=False)
     path: Path | None = field(default=None, repr=False)
     config_path: Path | None = field(default=None, repr=False)
+    script_path: Path | None = field(default=None, repr=False)
 
     @property
     def previous(self):
@@ -54,13 +55,6 @@ class Report():
                 state = 'Outdated'
         return state
 
-    @property
-    def config(self):
-        if self.config_path is not None and self.base_path is not None:
-            return load_config(self.config_path, self.base_path)
-        else:
-            return None
-
     @state.setter
     def state(self, state: Literal['OK', 'Bad', 'Outdated', 'In spec',
                                    'Out of spec', 'Bad data']):
@@ -80,6 +74,20 @@ class Report():
             self.bad_data = False
             self.in_spec = False
 
+    @property
+    def config(self):
+        if self.config_path is not None and self.base_path is not None:
+            return load_item(self.config_path, self.base_path)
+        else:
+            return None
+
+    @property
+    def script(self):
+        if self.script_path is not None and self.base_path is not None:
+            return load_item(self.script_path, self.base_path)
+        else:
+            return None
+
 
 def random_path(base: Path) -> Path:
     while True:
@@ -149,27 +157,27 @@ def save_report(workflow: str,
         f'Saving report for "{workflow}", {report.in_spec=}, {report.bad_data=}, {report.fully_calibrated=}'
     )
     base_path = Path(base_path)
-    if overwrite:
+    try:
         buf = lzma.compress(pickle.dumps(report))
+    except:
+        raise ValueError(f"Can't pickle report for {workflow}")
+    if overwrite:
         path = report.path
         if path is None:
             raise ValueError("Report path is None, can't overwrite.")
-        with open(base_path / 'objects' / path, "rb") as f:
+        with open(base_path / 'reports' / path, "rb") as f:
             index = int.from_bytes(f.read(8), 'big')
         report.index = index
     else:
-        report.previous_path = get_head(workflow, base_path)
-        buf = lzma.compress(pickle.dumps(report))
-        path = random_path(base_path / 'objects')
-        (base_path / 'objects' / path).parent.mkdir(parents=True,
+        path = random_path(base_path / 'reports')
+        (base_path / 'reports' / path).parent.mkdir(parents=True,
                                                     exist_ok=True)
         report.path = path
         report.index = create_index("report",
                                     base_path,
                                     context=str(path),
                                     width=35)
-
-    with open(base_path / 'objects' / path, "wb") as f:
+    with open(base_path / 'reports' / path, "wb") as f:
         f.write(report.index.to_bytes(8, 'big'))
         f.write(buf)
     if refresh_heads:
@@ -179,9 +187,9 @@ def save_report(workflow: str,
 
 def load_report(path: str | Path, base_path: str | Path) -> Report | None:
     base_path = Path(base_path)
-    path = base_path / 'objects' / path
+    path = base_path / 'reports' / path
 
-    with open(base_path / 'objects' / path, "rb") as f:
+    with open(base_path / 'reports' / path, "rb") as f:
         index = int.from_bytes(f.read(8), 'big')
         report = pickle.loads(lzma.decompress(f.read()))
         report.base_path = base_path
@@ -202,22 +210,30 @@ def find_report(
     return load_report(path, base_path)
 
 
-def renew_report(workflow: str, report, base_path: str | Path):
+def renew_report(workflow: str, report: Report | None, base_path: str | Path):
     logger.debug(f'Renewing report for "{workflow}"')
-    report = find_report(workflow, base_path)
     if report is not None:
         report.checked_time = datetime.now()
-        return save_report(workflow, report, base_path)
+        return save_report(workflow,
+                           report,
+                           base_path,
+                           overwrite=True,
+                           refresh_heads=True)
+    else:
+        raise ValueError(f"Can't renew report for {workflow}")
 
 
-def revoke_report(workflow: str, report, base_path: str | Path):
+def revoke_report(workflow: str, report: Report | None, base_path: str | Path):
     logger.debug(f'Revoking report for "{workflow}"')
     base_path = Path(base_path)
-    path = get_head(workflow, base_path)
-    if path is not None:
-        report = load_report(path, base_path)
+    if report is not None:
         report.in_spec = False
-        return save_report(workflow, report, base_path)
+        report.previous_path = report.path
+        return save_report(workflow,
+                           report,
+                           base_path,
+                           overwrite=False,
+                           refresh_heads=True)
 
 
 def set_head(workflow: str, path: Path, base_path: str | Path):
@@ -307,18 +323,17 @@ def get_report_by_index(
         return None
 
 
-def save_config(cfg, data_path):
-    i = 0
-    buf = pickle.dumps(cfg)
+def save_item(item, data_path):
+    salt = 0
+    buf = pickle.dumps(item)
     buf = lzma.compress(buf)
     h = hashlib.md5(buf)
 
     while True:
-        salt = f"{i}".encode()
-        h.update(salt)
+        h.update(f"{salt}".encode())
         hashstr = h.hexdigest()
-        cfg_id = Path(hashstr[:2]) / hashstr[2:4] / hashstr[4:]
-        path = Path(data_path) / 'config' / cfg_id
+        item_id = Path(hashstr[:2]) / hashstr[2:4] / hashstr[4:]
+        path = Path(data_path) / 'items' / item_id
         if not path.exists():
             path.parent.mkdir(parents=True, exist_ok=True)
             with open(path, 'wb') as f:
@@ -326,13 +341,13 @@ def save_config(cfg, data_path):
             break
         elif path.read_bytes() == buf:
             break
-        i += 1
-    return str(cfg_id)
+        salt += 1
+    return str(item_id)
 
 
-@lru_cache(maxsize=1024)
-def load_config(id, data_path):
-    path = Path(data_path) / 'config' / id
+@lru_cache(maxsize=4096)
+def load_item(id, data_path):
+    path = Path(data_path) / 'items' / id
     with open(path, 'rb') as f:
         buf = f.read()
     cfg = pickle.loads(lzma.decompress(buf))

qulab/executor/transform.py

@@ -1,4 +1,4 @@
-from .storage import Report, save_config
+from .storage import Report, save_item
 
 __current_config_id = None
 
@@ -47,21 +47,21 @@ def obey_the_oracle(report: Report, data_path):
     global __current_config_id
     update_config(report.oracle)
     cfg = export_config()
-    __current_config_id = save_config(cfg, data_path)
+    __current_config_id = save_item(cfg, data_path)
 
 
 def update_parameters(report: Report, data_path):
     global __current_config_id
     update_config(report.parameters)
     cfg = export_config()
-    __current_config_id = save_config(cfg, data_path)
+    __current_config_id = save_item(cfg, data_path)
 
 
 def current_config(data_path):
     global __current_config_id
     if __current_config_id is None:
         cfg = export_config()
-        __current_config_id = save_config(cfg, data_path)
+        __current_config_id = save_item(cfg, data_path)
     return __current_config_id
 
 

qulab/version.py

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