QuLab 2.4.20__tar.gz → 2.5.0__tar.gz

{qulab-2.4.20 → qulab-2.5.0}/PKG-INFO

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

{qulab-2.4.20 → qulab-2.5.0}/QuLab.egg-info/PKG-INFO

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

{qulab-2.4.20 → qulab-2.5.0}/QuLab.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ qulab/__main__.py
 qulab/dicttree.py
 qulab/version.py
 qulab/cli/__init__.py
+qulab/cli/commands.py
 qulab/cli/config.py
 qulab/executor/__init__.py
 qulab/executor/cli.py

{qulab-2.4.20 → qulab-2.5.0}/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-2.4.20 → qulab-2.5.0}/qulab/__main__.py

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

{qulab-2.4.20 → qulab-2.5.0}/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-2.4.20 → qulab-2.5.0}/qulab/executor/load.py

@@ -269,7 +269,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-2.4.20 → qulab-2.5.0}/qulab/executor/schedule.py

@@ -7,8 +7,8 @@ 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)
 
 
 class CalibrationFailedError(Exception):
@@ -120,13 +120,14 @@ 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}" !')
+        logger.debug(f'Checked "{workflow.__workflow_id__}" !')
         result = call_analyzer(workflow, data, history, check=True, plot=plot)
         if result.in_spec:
             logger.debug(
@@ -149,8 +150,10 @@ def check_data(workflow: WorkflowType, code_path: str | 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))
+        save_result(workflow.__workflow_id__,
+                    result,
+                    state_path,
+                    overwrite=True)
 
     return result
 
@@ -167,8 +170,7 @@ def calibrate(workflow: WorkflowType, code_path: str | Path,
     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))
+    save_result(workflow.__workflow_id__, result, state_path, overwrite=True)
     return result
 
 

qulab-2.5.0/qulab/executor/storage.py

@@ -0,0 +1,191 @@
+import lzma
+import pickle
+import uuid
+from dataclasses import dataclass, field
+from datetime import datetime, timedelta
+from pathlib import Path
+
+from loguru import logger
+
+from ..cli.config import get_config_value
+
+
+@dataclass
+class Result():
+    in_spec: bool = False
+    bad_data: bool = False
+    fully_calibrated: bool = False
+    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)
+    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
+
+
+def random_path(base: Path) -> Path:
+    while True:
+        s = uuid.uuid4().hex
+        path = Path(s[:2]) / s[2:4] / s[4:6] / s[6:]
+        if not (base / path).exists():
+            return path
+
+
+def save_result(workflow: str,
+                result: Result,
+                base_path: str | Path,
+                overwrite: bool = False):
+    logger.debug(
+        f'Saving result for "{workflow}", {result.in_spec=}, {result.bad_data=}, {result.fully_calibrated=}'
+    )
+    base_path = Path(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:
+        f.write(result.index.to_bytes(8, 'big'))
+        f.write(buf)
+    set_head(workflow, path, base_path)
+
+
+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
+    return load_result(path, base_path)
+
+
+def renew_result(workflow: str, base_path: str | Path):
+    logger.debug(f'Renewing result for "{workflow}"')
+    result = find_result(workflow, base_path)
+    if result is not None:
+        result.checked_time = datetime.now()
+        save_result(workflow, result, base_path)
+
+
+def revoke_result(workflow: str, base_path: str | Path):
+    logger.debug(f'Revoking result for "{workflow}"')
+    base_path = Path(base_path)
+    path = get_head(workflow, base_path)
+    if path is not None:
+        with open(base_path / 'objects' / path, "rb") as f:
+            result = pickle.load(f)
+        result.in_spec = False
+        save_result(workflow, result, base_path)
+
+
+def set_head(workflow: str, path: Path, base_path: str | Path):
+    base_path = Path(base_path)
+    base_path.mkdir(parents=True, exist_ok=True)
+    try:
+        with open(base_path / "heads", "rb") as f:
+            heads = pickle.load(f)
+    except:
+        heads = {}
+    heads[workflow] = path
+    with open(base_path / "heads", "wb") as f:
+        pickle.dump(heads, f)
+
+
+def get_head(workflow: str, 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[workflow]
+    except:
+        return None
+
+
+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:
+        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-2.4.20 → qulab-2.5.0}/qulab/executor/utils.py

@@ -31,10 +31,9 @@ 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
+    return f"""from loguru import logger
 
-def VAR(s): pass
+def VAR(s): pass  # 没有实际作用，只是用来抑制编辑器的警告。
 
 import numpy as np
 

qulab-2.5.0/qulab/version.py

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

qulab-2.4.20/qulab/executor/storage.py

@@ -1,147 +0,0 @@
-import pickle
-import uuid
-from dataclasses import dataclass, field
-from datetime import datetime, timedelta
-from pathlib import Path
-
-from loguru import logger
-
-
-@dataclass
-class Result():
-    in_spec: bool = False
-    bad_data: bool = False
-    fully_calibrated: bool = False
-    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)
-
-
-def random_path(base: Path) -> Path:
-    while True:
-        s = uuid.uuid4().hex
-        path = Path(s[:2]) / s[2:4] / s[4:6] / s[6:]
-        if not (base / path).exists():
-            return path
-
-
-def save_result(workflow: str,
-                result: Result,
-                base_path: str | Path,
-                path: Path | None = None):
-    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)
-    with open(base_path / 'objects' / path, "wb") as f:
-        pickle.dump(result, f)
-    set_head(workflow, path, base_path)
-
-
-def find_result(workflow: str, base_path: str | 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)
-
-
-def renew_result(workflow: str, base_path: str | Path):
-    logger.debug(f'Renewing result for "{workflow}"')
-    result = find_result(workflow, base_path)
-    if result is not None:
-        result.checked_time = datetime.now()
-        save_result(workflow, result, base_path)
-
-
-def revoke_result(workflow: str, base_path: str | Path):
-    logger.debug(f'Revoking result for "{workflow}"')
-    base_path = Path(base_path)
-    path = get_head(workflow, base_path)
-    if path is not None:
-        with open(base_path / 'objects' / path, "rb") as f:
-            result = pickle.load(f)
-        result.in_spec = False
-        save_result(workflow, result, base_path)
-
-
-def set_head(workflow: str, path: Path, base_path: str | Path):
-    base_path = Path(base_path)
-    base_path.mkdir(parents=True, exist_ok=True)
-    try:
-        with open(base_path / "heads", "rb") as f:
-            heads = pickle.load(f)
-    except:
-        heads = {}
-    heads[workflow] = path
-    with open(base_path / "heads", "wb") as f:
-        pickle.dump(heads, f)
-
-
-def get_head(workflow: str, 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[workflow]
-    except:
-        return None
-
-
-def get_graph(base_path: str | Path) -> dict[str, list[str]]:
-    base_path = Path(base_path)
-    try:
-        with open(base_path / "heads", "rb") as f:
-            heads = pickle.load(f)
-    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)

qulab-2.4.20/qulab/version.py

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