QuLab 2.4.20__cp311-cp311-win_amd64.whl → 2.5.1__cp311-cp311-win_amd64.whl

{QuLab-2.4.20.dist-info → QuLab-2.5.1.dist-info}/METADATA

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

{QuLab-2.4.20.dist-info → QuLab-2.5.1.dist-info}/RECORD

@@ -1,17 +1,19 @@
-qulab/__init__.py,sha256=vkFybY8YSsQilYdThPRD83-btPAR41sy_WCXiM-6mME,141
-qulab/__main__.py,sha256=g9iBs8xxX6Yik7cmgllQkpBN8C4JNoZVsEOyCCLCyFU,63
+qulab/__init__.py,sha256=pdlicy07Dx39pTEGZ0i41Ox9tuuuKKIdsFIrE13bneg,249
+qulab/__main__.py,sha256=FL4YsGZL1jEtmcPc5WbleArzhOHLMsWl7OH3O-1d1ss,72
 qulab/dicttree.py,sha256=ZoSJVWK4VMqfzj42gPb_n5RqLlM6K1Me0WmLIfLEYf8,14195
-qulab/fun.cp311-win_amd64.pyd,sha256=R96iJRfL-QZSf9reOnccgip5md-3EdMl21n0JSZs4lY,31744
-qulab/version.py,sha256=0EYwz_vOIrGy7c3cr82zYeYGyK4QxRsY1XkcDC_j6SI,22
-qulab/cli/__init__.py,sha256=6xd2eYw32k1NmfAuYSu__1kaP12Oz1QVqwbkYXdWno4,588
-qulab/cli/config.py,sha256=Loee8MwKFuDRWXttG8iBY9ZmD5xSCHDFi3ztt2i0S_0,3139
+qulab/fun.cp311-win_amd64.pyd,sha256=GySZYYfMEL41c4mC5SdGt6pDagUrmnU-bAtD9HZLWv4,31744
+qulab/typing.py,sha256=3c0eKa1avEHIi5wPvh3-4l6Of5mu5Rn1MWPnMeLGNX0,71
+qulab/version.py,sha256=LBVD6Y5IKVHVmwynNRJsCm7zBTye77uIsmOVQJQUroE,21
+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=owdDSaSuzTPQA5SlNCxX4nHWITU1BF0VZMj7tLqCZhM,5781
-qulab/executor/load.py,sha256=fZNmsOGR_2s1IykVmVwziDKeWCIej-jRJAQzKJRUdaE,11990
-qulab/executor/schedule.py,sha256=bXQzn3e3tCvAVdEBsvh5ecAThP52njyxbsrlrxC9TzA,11922
-qulab/executor/storage.py,sha256=M66Q5_Uc5MMfc_QAuuaaexwAz7wxBPMkeleB5nRpQmI,4621
-qulab/executor/transform.py,sha256=inaOn6eqCs22ZZ0xAQl8s8YCoEACaXSwFNNu7jqdwAk,2148
-qulab/executor/utils.py,sha256=_9EZkx2rBpsWjhDN5BZ-Lq9MboqmHcI1jtwpRyrzSTY,3101
+qulab/executor/load.py,sha256=i2MKxE5kflAGLt3e9LjME59K7IO7s68EUApP9228LhQ,12125
+qulab/executor/schedule.py,sha256=4D8o68Cx6vCkpSTMHzULTwuuq1tS8unc2n8WdBA9oB0,12013
+qulab/executor/storage.py,sha256=Ms4euSGrMnFJPwcs70sg5-ZOOm1B6kGULcZOipsFLk4,7242
+qulab/executor/transform.py,sha256=AazWdlkEoOBaUJpTYsT5J4f0RanzCEeo-ThwEg8BB4Y,1262
+qulab/executor/utils.py,sha256=RNDEo17M-n_tge7uLITHxmoNNYSTm9OES75wQygR8dM,4065
 qulab/monitor/__init__.py,sha256=xEVDkJF8issrsDeLqQmDsvtRmrf-UiViFcGTWuzdlFU,43
 qulab/monitor/__main__.py,sha256=k2H1H5Zf9LLXTDLISJkbikLH-z0f1e5i5i6wXXYPOrE,105
 qulab/monitor/config.py,sha256=y_5StMkdrbZO1ziyKBrvIkB7Jclp9RCPK1QbsOhCxnY,785
@@ -91,9 +93,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.4.20.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
-QuLab-2.4.20.dist-info/METADATA,sha256=LzlzxYnUG7CckjTxnZ2-2yJY7yfwUFlf5pll5JI_PV4,3804
-QuLab-2.4.20.dist-info/WHEEL,sha256=yNnHoQL2GZYIUXm9YvoaBpFjGlUoK9qq9oqYeudrWlE,101
-QuLab-2.4.20.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
-QuLab-2.4.20.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-QuLab-2.4.20.dist-info/RECORD,,
+QuLab-2.5.1.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
+QuLab-2.5.1.dist-info/METADATA,sha256=SpfzBYK0REQ2vkduzKiMwa2hGCl0JRkexh522Lf3HkM,3803
+QuLab-2.5.1.dist-info/WHEEL,sha256=yNnHoQL2GZYIUXm9YvoaBpFjGlUoK9qq9oqYeudrWlE,101
+QuLab-2.5.1.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
+QuLab-2.5.1.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+QuLab-2.5.1.dist-info/RECORD,,

qulab/__init__.py

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

qulab/__main__.py

@@ -1,4 +1,4 @@
-from .cli import cli
+from .cli.commands import cli
 
 if __name__ == '__main__':
     cli()

qulab/cli/__init__.py

@@ -1,29 +0,0 @@
-import click
-
-from ..executor.cli import create, get, maintain, run, set
-from ..monitor.__main__ import main as monitor
-from ..scan.server import server
-from ..sys.net.cli import dht
-from ..visualization.__main__ import plot
-
-
-@click.group()
-def cli():
-    pass
-
-
-@cli.command()
-def hello():
-    """Print hello world."""
-    click.echo('hello, world')
-
-
-cli.add_command(monitor)
-cli.add_command(plot)
-cli.add_command(dht)
-cli.add_command(server)
-cli.add_command(maintain)
-cli.add_command(run)
-cli.add_command(create)
-cli.add_command(set)
-cli.add_command(get)

qulab/cli/commands.py

@@ -0,0 +1,29 @@
+import click
+
+from ..executor.cli import create, get, maintain, run, set
+from ..monitor.__main__ import main as monitor
+from ..scan.server import server
+from ..sys.net.cli import dht
+from ..visualization.__main__ import plot
+
+
+@click.group()
+def cli():
+    pass
+
+
+@cli.command()
+def hello():
+    """Print hello world."""
+    click.echo('hello, world')
+
+
+cli.add_command(monitor)
+cli.add_command(plot)
+cli.add_command(dht)
+cli.add_command(server)
+cli.add_command(maintain)
+cli.add_command(run)
+cli.add_command(create)
+cli.add_command(set)
+cli.add_command(get)

qulab/cli/config.py

@@ -62,27 +62,35 @@ def log_options(func):
 
     @click.option("--debug",
                   is_flag=True,
-                  default=lambda: get_config_value("debug", bool) or False,
+                  default=get_config_value("debug", bool),
                   help=f"Enable debug mode")
     @click.option("--log",
                   type=click.Path(),
                   default=lambda: get_config_value("log", Path),
                   help=f"Log file path")
+    @click.option("--quiet",
+                  is_flag=True,
+                  default=get_config_value("quiet", bool),
+                  help=f"Disable log output")
     @functools.wraps(func)
-    def wrapper(*args, log=None, debug=False, **kwargs):
-        if log is None and not debug:
-            logger.remove()
-            logger.add(sys.stderr, level='INFO')
-        elif log is None and debug:
-            logger.remove()
-            logger.add(sys.stderr, level='DEBUG')
-        elif log is not None and not debug:
-            logger.configure(handlers=[dict(sink=log, level='INFO')])
-        elif log is not None and debug:
-            logger.configure(handlers=[
-                dict(sink=log, level='DEBUG'),
-                dict(sink=sys.stderr, level='DEBUG')
-            ])
+    def wrapper(*args, **kwargs):
+        debug = bool(kwargs.pop("debug"))
+        log = kwargs.pop("log")
+        quiet = bool(kwargs.pop("quiet"))
+
+        if debug:
+            log_level = "DEBUG"
+        else:
+            log_level = "INFO"
+
+        handlers = []
+        if log is not None:
+            handlers.append(dict(sink=log, level=log_level))
+        if not quiet or debug:
+            handlers.append(dict(sink=sys.stderr, level=log_level))
+
+        logger.configure(handlers=handlers)
+
         return func(*args, **kwargs)
 
     return wrapper

qulab/executor/load.py

@@ -40,17 +40,21 @@ class SetConfigWorkflow():
             value = transform.query_config(self.key)
         except:
             value = eval(input(f'"{self.key}": '))
-        return self.key, value
+        return value
 
-    def analyze(self, key, value, history):
-        return 'OK', {key: value}, {}
+    def analyze(self, result: Result, history: Result):
+        result.state = 'OK'
+        result.parameters = {self.key: result.data}
+        return result
 
     def check(self):
         from .transform import query_config
-        return self.key, query_config(self.key)
+        return query_config(self.key)
 
-    def check_analyze(self, key, value, history):
-        return 'Out of Spec', {key: value}, {}
+    def check_analyze(self, result: Result, history: Result):
+        result.state = 'Outdated'
+        result.parameters = {self.key: result.data}
+        return result
 
     @staticmethod
     def _equal(a, b):
@@ -269,7 +273,7 @@ def load_workflow_from_template(template_path: str,
             str: 已经替换的新字符串。
         """
         pattern = re.compile(r'VAR\s*\(\s*(["\'])(\w+)\1\s*\)')
-        replacement = f'__VAR_{hash_str}' + r'["\2"]'
+        replacement = f'__VAR_{hash_str}' + r'[\1\2\1]'
         new_text = re.sub(pattern, replacement, text)
         return new_text
 

qulab/executor/schedule.py

@@ -5,10 +5,10 @@ from pathlib import Path
 
 from loguru import logger
 
-from . import transform
 from .load import WorkflowType, get_dependents
-from .storage import (Result, find_result, get_head, renew_result,
-                      revoke_result, save_result)
+from .storage import (Result, find_result, renew_result, revoke_result,
+                      save_result)
+from .transform import update_parameters
 
 
 class CalibrationFailedError(Exception):
@@ -66,27 +66,26 @@ def check_state(workflow: WorkflowType, code_path: str | Path,
     return True
 
 
-def call_analyzer(node, data, history, check=False, plot=False):
+def call_analyzer(node,
+                  result: Result,
+                  history: Result | None,
+                  check=False,
+                  plot=False) -> Result:
     if check:
-        result = transform.params_to_result(
-            node.check_analyze(*data,
-                               history=transform.result_to_params(history)))
+        result = node.check_analyze(result, history=history)
         result.fully_calibrated = False
     else:
-        result = transform.params_to_result(
-            node.analyze(*data, history=transform.result_to_params(history)))
+        result = node.analyze(result, history=history)
         result.fully_calibrated = True
         if plot:
             call_plot(node, result)
-    result.data = data
     return result
 
 
 @logger.catch()
-def call_plot(node, result, check=False):
+def call_plot(node, result: Result, check=False):
     if hasattr(node, 'plot') and callable(node.plot):
-        state, params, other = transform.result_to_params(result)
-        node.plot(state, params, other)
+        node.plot(result)
 
 
 @functools.lru_cache(maxsize=128)
@@ -120,14 +119,19 @@ def check_data(workflow: WorkflowType, code_path: str | Path,
 
     if hasattr(workflow, 'check') and callable(workflow.check) and hasattr(
             workflow, 'check_analyze') and callable(workflow.check_analyze):
-        logger.debug(f'Checking "{workflow}" with "check" method ...')
+        logger.debug(
+            f'Checking "{workflow.__workflow_id__}" with "check" method ...')
         data = workflow.check()
         result = Result()
         result.data = data
-        save_result(workflow.__workflow_id__, result, state_path)
+        #save_result(workflow.__workflow_id__, result, state_path)
 
-        logger.debug(f'Checked "{workflow}" !')
-        result = call_analyzer(workflow, data, history, check=True, plot=plot)
+        logger.debug(f'Checked "{workflow.__workflow_id__}" !')
+        result = call_analyzer(workflow,
+                               result,
+                               history,
+                               check=True,
+                               plot=plot)
         if result.in_spec:
             logger.debug(
                 f'"{workflow.__workflow_id__}": checked in spec, renewing result'
@@ -148,9 +152,15 @@ def check_data(workflow: WorkflowType, code_path: str | Path,
         save_result(workflow.__workflow_id__, result, state_path)
 
         logger.debug(f'Calibrated "{workflow}" !')
-        result = call_analyzer(workflow, data, history, check=False, plot=plot)
-        save_result(workflow.__workflow_id__, result, state_path,
-                    get_head(workflow.__workflow_id__, state_path))
+        result = call_analyzer(workflow,
+                               result,
+                               history,
+                               check=False,
+                               plot=plot)
+        save_result(workflow.__workflow_id__,
+                    result,
+                    state_path,
+                    overwrite=True)
 
     return result
 
@@ -166,9 +176,8 @@ def calibrate(workflow: WorkflowType, code_path: str | Path,
     result.data = data
     save_result(workflow.__workflow_id__, result, state_path)
     logger.debug(f'Calibrated "{workflow.__workflow_id__}" !')
-    result = call_analyzer(workflow, data, history, check=False, plot=plot)
-    save_result(workflow.__workflow_id__, result, state_path,
-                get_head(workflow.__workflow_id__, state_path))
+    result = call_analyzer(workflow, result, history, check=False, plot=plot)
+    save_result(workflow.__workflow_id__, result, state_path, overwrite=True)
     return result
 
 
@@ -226,7 +235,7 @@ def diagnose(workflow: WorkflowType, code_path: str | Path,
         raise CalibrationFailedError(
             f'"{workflow.__workflow_id__}": All dependents passed, but calibration failed!'
         )
-    transform.update_parameters(result)
+    update_parameters(result)
     return True
 
 
@@ -282,7 +291,7 @@ def maintain(workflow: WorkflowType,
             f'"{workflow.__workflow_id__}": All dependents passed, but calibration failed!'
         )
     if update:
-        transform.update_parameters(result)
+        update_parameters(result)
     return
 
 
@@ -304,5 +313,5 @@ def run(workflow: WorkflowType,
             f'"{workflow.__workflow_id__}": All dependents passed, but calibration failed!'
         )
     if update:
-        transform.update_parameters(result)
+        update_parameters(result)
     return

qulab/executor/storage.py

@@ -1,11 +1,15 @@
+import lzma
 import pickle
 import uuid
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from pathlib import Path
+from typing import Any, Literal
 
 from loguru import logger
 
+from ..cli.config import get_config_value
+
 
 @dataclass
 class Result():
@@ -15,28 +19,50 @@ class Result():
     calibrated_time: datetime = field(default_factory=datetime.now)
     checked_time: datetime = field(default_factory=datetime.now)
     ttl: timedelta = timedelta(days=3650)
-    params: dict = field(default_factory=dict)
-    info: dict = field(default_factory=dict)
-    data: tuple = field(default_factory=tuple)
-    previous: Path | None = None
-
-
-class Graph:
-
-    def __init__(self):
-        self.nodes = {}
-        self.heads = set()
-        self.roots = set()
-
-    def add_node(self, node: str, deps: list[str]):
-        if node not in self.nodes:
-            self.nodes[node] = deps
-            if not deps:
-                self.heads.add(node)
-            for dep in deps:
-                if dep not in self.nodes:
-                    self.nodes[dep] = []
-                self.roots.discard(dep)
+    parameters: dict = field(default_factory=dict)
+    other_infomation: dict = field(default_factory=dict)
+    data: Any = field(default_factory=tuple)
+    index: int = -1
+    previous_path: Path | None = None
+    base_path: Path | None = None
+
+    @property
+    def previous(self):
+        if self.previous_path is not None and self.base_path is not None:
+            return load_result(self.previous_path, self.base_path)
+        else:
+            return None
+
+    @property
+    def state(self) -> Literal['OK', 'Bad', 'Outdated']:
+        state = 'Bad'
+        match (self.in_spec, self.bad_data):
+            case (True, False):
+                state = 'OK'
+            case (False, True):
+                state = 'Bad'
+            case (False, False):
+                state = 'Outdated'
+        return state
+
+    @state.setter
+    def state(self, state: Literal['OK', 'Bad', 'Outdated', 'In spec',
+                                   'Out of spec', 'Bad data']):
+        if state not in [
+                'OK', 'Bad', 'Outdated', 'In spec', 'Out of spec', 'Bad data'
+        ]:
+            raise ValueError(
+                f'Invalid state: {state}, state must be one of "OK", "Bad" and "Outdated"'
+            )
+        if state in ['In spec', 'OK']:
+            self.in_spec = True
+            self.bad_data = False
+        elif state in ['Bad data', 'Bad']:
+            self.bad_data = True
+            self.in_spec = False
+        else:
+            self.bad_data = False
+            self.in_spec = False
 
 
 def random_path(base: Path) -> Path:
@@ -50,27 +76,55 @@ def random_path(base: Path) -> Path:
 def save_result(workflow: str,
                 result: Result,
                 base_path: str | Path,
-                path: Path | None = None):
+                overwrite: bool = False) -> int:
     logger.debug(
         f'Saving result for "{workflow}", {result.in_spec=}, {result.bad_data=}, {result.fully_calibrated=}'
     )
     base_path = Path(base_path)
-    if path is None:
-        path = random_path(base_path)
-    (base_path / 'objects' / path).parent.mkdir(parents=True, exist_ok=True)
-    result.previous = get_head(workflow, base_path)
+    if overwrite:
+        buf = lzma.compress(pickle.dumps(result))
+        path = get_head(workflow, base_path)
+        with open(base_path / 'objects' / path, "rb") as f:
+            index = int.from_bytes(f.read(8), 'big')
+        result.index = index
+    else:
+        result.previous_path = get_head(workflow, base_path)
+        buf = lzma.compress(pickle.dumps(result))
+        path = random_path(base_path / 'objects')
+        (base_path / 'objects' / path).parent.mkdir(parents=True,
+                                                    exist_ok=True)
+        result.index = create_index("result",
+                                    base_path,
+                                    context=str(path),
+                                    width=35)
+
     with open(base_path / 'objects' / path, "wb") as f:
-        pickle.dump(result, f)
+        f.write(result.index.to_bytes(8, 'big'))
+        f.write(buf)
     set_head(workflow, path, base_path)
+    return result.index
 
 
-def find_result(workflow: str, base_path: str | Path) -> Result | None:
+def load_result(path: str | Path, base_path: str | Path) -> Result | None:
+    base_path = Path(base_path)
+    path = base_path / 'objects' / path
+
+    with open(base_path / 'objects' / path, "rb") as f:
+        index = int.from_bytes(f.read(8), 'big')
+        result = pickle.loads(lzma.decompress(f.read()))
+        result.base_path = base_path
+        result.index = index
+        return result
+
+
+def find_result(
+    workflow: str, base_path: str | Path = get_config_value("data", Path)
+) -> Result | None:
     base_path = Path(base_path)
     path = get_head(workflow, base_path)
     if path is None:
         return None
-    with open(base_path / 'objects' / path, "rb") as f:
-        return pickle.load(f)
+    return load_result(path, base_path)
 
 
 def renew_result(workflow: str, base_path: str | Path):
@@ -78,7 +132,7 @@ def renew_result(workflow: str, base_path: str | Path):
     result = find_result(workflow, base_path)
     if result is not None:
         result.checked_time = datetime.now()
-        save_result(workflow, result, base_path)
+        return save_result(workflow, result, base_path)
 
 
 def revoke_result(workflow: str, base_path: str | Path):
@@ -89,7 +143,7 @@ def revoke_result(workflow: str, base_path: str | Path):
         with open(base_path / 'objects' / path, "rb") as f:
             result = pickle.load(f)
         result.in_spec = False
-        save_result(workflow, result, base_path)
+        return save_result(workflow, result, base_path)
 
 
 def set_head(workflow: str, path: Path, base_path: str | Path):
@@ -115,33 +169,56 @@ def get_head(workflow: str, base_path: str | Path) -> Path | None:
         return None
 
 
-def get_graph(base_path: str | Path) -> dict[str, list[str]]:
+def get_heads(base_path: str | Path) -> Path | None:
     base_path = Path(base_path)
     try:
         with open(base_path / "heads", "rb") as f:
             heads = pickle.load(f)
+        return heads
     except:
-        heads = {}
-    graph = {}
-    for workflow, path in heads.items():
-        graph[workflow] = []
-        while path is not None:
-            with open(base_path / 'objects' / path, "rb") as f:
-                result = pickle.load(f)
-            path = result.previous
-            if path is not None:
-                graph[workflow].append(path)
-    return graph
-
-
-def update_graph(workflow: str, base_path: str | Path):
-    base_path = Path(base_path)
-    graph = get_graph(base_path)
-    for workflow, deps in graph.items():
-        for dep in deps:
-            if dep not in graph:
-                graph[dep] = []
-            if workflow not in graph[dep]:
-                graph[dep].append(workflow)
-    with open(base_path / "graph", "wb") as f:
-        pickle.dump(graph, f)
+        return {}
+
+
+def create_index(name: str,
+                 base_path: str | Path,
+                 context: str,
+                 width: int,
+                 start: int = 0):
+    path = Path(base_path) / "index" / f"{name}.seq"
+    if path.exists():
+        with open(path, "r") as f:
+            index = int(f.read())
+    else:
+        index = start
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w") as f:
+        f.write(str(index + 1))
+
+    path = Path(base_path) / "index" / f"{name}.width"
+    with open(path, "w") as f:
+        f.write(str(width))
+
+    path = Path(base_path) / "index" / f"{name}.idx"
+    with open(path, "a") as f:
+
+        f.write(f"{context.ljust(width)}\n")
+
+    return index
+
+
+def query_index(name: str, base_path: str | Path, index: int):
+    path = Path(base_path) / "index" / f"{name}.width"
+    with open(path, "r") as f:
+        width = int(f.read())
+    path = Path(base_path) / "index" / f"{name}.idx"
+    with open(path, "r") as f:
+        f.seek(index * (width + 1))
+        context = f.read(width)
+    return context.rstrip()
+
+
+def get_result_by_index(
+    index: int, base_path: str | Path = get_config_value("data", Path)
+) -> Result | None:
+    path = query_index("result", base_path, index)
+    return load_result(path, base_path)

qulab/executor/transform.py

@@ -1,5 +1,3 @@
-import loguru
-
 from .storage import Result
 
 
@@ -32,40 +30,7 @@ def _update_config(updates):
 
 
 def update_parameters(result: Result):
-    update_config(result.params)
-
-
-def result_to_params(result: Result | None) -> tuple | None:
-    if result is None:
-        return None
-
-    state = 'Bad data'
-    match (result.in_spec, result.bad_data):
-        case (True, False):
-            state = 'In spec'
-        case (False, True):
-            state = 'Bad data'
-        case (False, False):
-            state = 'Out of spec'
-
-    return state, result.params, result.info
-
-
-def params_to_result(params: tuple) -> Result:
-    state, cali, info = params
-    result = Result()
-    if state in ['In spec', 'OK']:
-        result.in_spec = True
-        result.bad_data = False
-    elif state in ['Bad data', 'Bad']:
-        result.bad_data = True
-        result.in_spec = False
-    else:
-        result.bad_data = False
-        result.in_spec = False
-    result.params = cali
-    result.info = info
-    return result
+    update_config(result.parameters)
 
 
 query_config = _query_config

qulab/executor/utils.py

@@ -31,12 +31,12 @@ def dependent_tree(node: str, code_path: str | Path) -> dict[str, list[str]]:
 
 
 def workflow_template(deps: list[str]) -> str:
-    return f"""
-from loguru import logger
-
-def VAR(s): pass
+    return f"""def VAR(s): pass  # 没有实际作用，只是用来抑制编辑器的警告。
 
 import numpy as np
+from loguru import logger
+
+from qulab.typing import Result
 
 
 # 多长时间应该检查一次校准实验，单位是秒。
@@ -61,23 +61,35 @@ def calibrate():
     return x, y
 
 
-def analyze(*args, history):
+def analyze(result: Result, history: Result | None) -> Result:
+    \"\"\"
+    分析校准结果。
+
+    result: Result
+        本次校准实验的数据。
+    history: Result | None
+        上次校准实验数据和分析结果，如果有的话。
+    \"\"\"
     import random
 
+    # 这里添加你的分析过程，运行 calibrate 得到的数据，在 result.data 里
+    # 你可以得到校准的结果，然后根据这个结果进行分析。
+    x, y = result.data
+
     # 完整校准后的状态有两种：OK 和 Bad，分别对应校准成功和校准失败。
     # 校准失败是指出现坏数据，无法简单通过重新运行本次校准解决，需要
     # 检查前置步骤。
-    state = random.choice(['OK', 'Bad'])
+    result.state = random.choice(['OK', 'Bad'])
 
     # 参数是一个字典，包含了本次校准得到的参数，后续会更新到config表中。
-    parameters = {{'gate.R.Q1.params.amp':1}}
+    result.parameters = {{'gate.R.Q1.params.amp':1}}
 
     # 其他信息可以是任何可序列化的内容，你可以将你想要记录的信息放在这里。
     # 下次校准分析时，这些信息也会在 history 参数中一起传入，帮助你在下
     # 次分析时对比参考。
-    other_infomation = {{}}
+    result.other_infomation = {{}}
 
-    return state, parameters, other_infomation
+    return result
 
 
 def check():
@@ -96,14 +108,26 @@ def check():
     return x, y
 
 
-def check_analyze(*args, history):
+def check_analyze(result: Result, history: Result) -> Result:
+    \"\"\"
+    分析检查结果。
+
+    result: Result
+        本次检查实验的数据。
+    history: Result | None
+        上次检查实验数据和分析结果，如果有的话。
+    \"\"\"
     import random
 
+    # 这里添加你的分析过程，运行 check 得到的数据，在 result.data 里
+    # 你可以得到校准的结果，然后根据这个结果进行分析。
+    x, y = result.data
+
     # 状态有三种：Outdated, OK, Bad，分别对应过时、正常、坏数据。
     # Outdated 是指数据过时，即参数漂了，需要重新校准。
     # OK 是指数据正常，参数也没漂，不用重新校准。
     # Bad 是指数据坏了，无法校准，需要检查前置步骤。
-    state = random.choice(['Outdated', 'OK', 'Bad'])
+    result.state = random.choice(['Outdated', 'OK', 'Bad'])
 
-    return state, {{}}, {{}}
+    return result
 """

qulab/typing.py

@@ -0,0 +1,2 @@
+from .executor.storage import Result
+from .scan.record import Record

qulab/version.py

@@ -1 +1 @@
-__version__ = "2.4.20"
+__version__ = "2.5.1"