QuLab 2.7.18__cp311-cp311-win_amd64.whl → 2.8.0__cp311-cp311-win_amd64.whl

qulab/executor/cli.py

@@ -2,6 +2,7 @@ import functools
 import graphlib
 import importlib
 import os
+import sys
 from pathlib import Path
 
 import click
@@ -68,6 +69,10 @@ def command_option(command_name):
             help='The path of the bootstrap.')
         @functools.wraps(func)
         def wrapper(*args, **kwargs):
+            if 'code' in kwargs and kwargs['code'] is not None:
+                code = os.path.expanduser(kwargs['code'])
+                if code not in sys.path:
+                    sys.path.insert(0, code)
             bootstrap = kwargs.pop('bootstrap')
             if bootstrap is not None:
                 boot(bootstrap)

qulab/executor/load.py

@@ -81,16 +81,6 @@ class SetConfigWorkflow():
 WorkflowType = ModuleType | SetConfigWorkflow
 
 
-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 can_call_without_args(func):
     if not callable(func):
         return False
@@ -320,6 +310,8 @@ def load_workflow_from_file(file_name: str,
     module = module_from_spec(spec)
     spec.loader.exec_module(module)
     module.__mtime__ = (base_path / path).stat().st_mtime
+    source_code = (base_path / path).read_text()
+    module.__source__ = source_code
 
     if hasattr(module, 'entries'):
         verify_entries(module, base_path)
@@ -347,11 +339,11 @@ def load_workflow_from_template(template_path: str,
     path = Path(template_path)
 
     with open(base_path / path) as f:
-        content = f.read()
+        template = f.read()
 
     mtime = max((base_path / template_path).stat().st_mtime, mtime)
 
-    content, hash_str = inject_mapping(content, mapping, str(path))
+    content, hash_str = inject_mapping(template, mapping, str(path))
 
     if target_path is None:
         if path.stem == 'template':
@@ -365,22 +357,19 @@ def load_workflow_from_template(template_path: str,
         path = target_path
 
     file = base_path / path
-    if not file.exists():
+    if not file.exists() or file.stat().st_mtime < mtime:
         file.parent.mkdir(parents=True, exist_ok=True)
         with open(file, 'w') as f:
             f.write(content)
-    else:
-        if file.stat().st_mtime < mtime:
-            with open(file, 'w') as f:
-                f.write(content)
-        else:
-            if file.read_text() != content:
-                logger.warning(
-                    f"`{file}` already exists and is different from the new one generated from template `{template_path}`"
-                )
+    elif file.read_text() != content:
+        logger.warning(
+            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.__mtime__ = max(mtime, module.__mtime__)
+    if module.__source__ == content:
+        module.__source__ = template, mapping, str(template_path)
 
     return module
 
@@ -422,8 +411,6 @@ def load_workflow(workflow: str | tuple[str, dict],
             w.__workflow_id__ = str(Path(w.__file__).relative_to(base_path))
     else:
         raise TypeError(f"Invalid workflow: {workflow}")
-    
-    w.__source__ = get_source(w, base_path)
 
     return w
 

qulab/executor/storage.py

@@ -2,6 +2,7 @@ import hashlib
 import lzma
 import pickle
 import uuid
+import zipfile
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from functools import lru_cache
@@ -10,6 +11,22 @@ from typing import Any, Literal
 
 from loguru import logger
 
+try:
+    from paramiko import SSHClient
+    from paramiko.ssh_exception import SSHException
+except:
+    class SSHClient:
+
+        def __init__(self):
+            raise ImportError("Can't import paramiko, ssh support will be disabled.")
+
+        def __enter__(self):
+            return self
+
+        def __exit__(self, exc_type, exc_value, traceback):
+            pass
+
+
 from ..cli.config import get_config_value
 
 __current_config_cache = None
@@ -36,6 +53,20 @@ class Report():
     config_path: Path | None = field(default=None, repr=False)
     script_path: Path | None = field(default=None, repr=False)
 
+    def __getstate__(self):
+        state = self.__dict__.copy()
+        state.pop('base_path')
+        for k in ['path', 'previous_path', 'config_path', 'script_path']:
+            if state[k] is not None:
+                state[k] = str(state[k])
+        return state
+
+    def __setstate__(self, state):
+        for k in ['path', 'previous_path', 'config_path', 'script_path']:
+            if state[k] is not None:
+                state[k] = Path(state[k])
+        self.__dict__.update(state)
+
     @property
     def previous(self):
         if self.previous_path is not None and self.base_path is not None:
@@ -84,7 +115,20 @@ class Report():
     @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)
+            source = load_item(self.script_path, self.base_path)
+            if isinstance(source, str):
+                return source
+            else:
+                from .template import inject_mapping
+                return inject_mapping(*source)[0]
+        else:
+            return None
+
+    @property
+    def template_source(self):
+        if self.script_path is not None and self.base_path is not None:
+            source = load_item(self.script_path, self.base_path)
+            return source
         else:
             return None
 
@@ -97,106 +141,6 @@ def random_path(base: Path) -> Path:
             return path
 
 
-def save_config_key_history(key: str, report: Report,
-                            base_path: str | Path) -> int:
-    global __current_config_cache
-    base_path = Path(base_path) / 'state'
-    base_path.mkdir(parents=True, exist_ok=True)
-
-    if __current_config_cache is None:
-        if (base_path / 'parameters.pkl').exists():
-            with open(base_path / 'parameters.pkl', 'rb') as f:
-                __current_config_cache = pickle.load(f)
-        else:
-            __current_config_cache = {}
-
-    __current_config_cache[
-        key] = report.data, report.calibrated_time, report.checked_time
-
-    with open(base_path / 'parameters.pkl', 'wb') as f:
-        pickle.dump(__current_config_cache, f)
-    return 0
-
-
-def find_config_key_history(key: str, base_path: str | Path) -> Report | None:
-    global __current_config_cache
-    base_path = Path(base_path) / 'state'
-    if __current_config_cache is None:
-        if (base_path / 'parameters.pkl').exists():
-            with open(base_path / 'parameters.pkl', 'rb') as f:
-                __current_config_cache = pickle.load(f)
-        else:
-            __current_config_cache = {}
-
-    if key in __current_config_cache:
-        value, calibrated_time, checked_time = __current_config_cache.get(
-            key, None)
-        report = Report(
-            workflow=f'cfg:{key}',
-            bad_data=False,
-            in_spec=True,
-            fully_calibrated=True,
-            parameters={key: value},
-            data=value,
-            calibrated_time=calibrated_time,
-            checked_time=checked_time,
-        )
-        return report
-    return None
-
-
-def save_report(workflow: str,
-                report: Report,
-                base_path: str | Path,
-                overwrite: bool = False,
-                refresh_heads: bool = True) -> int:
-    if workflow.startswith("cfg:"):
-        return save_config_key_history(workflow[4:], report, base_path)
-
-    logger.debug(
-        f'Saving report for "{workflow}", {report.in_spec=}, {report.bad_data=}, {report.fully_calibrated=}'
-    )
-    base_path = Path(base_path)
-    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 / 'reports' / path, "rb") as f:
-            index = int.from_bytes(f.read(8), 'big')
-        report.index = index
-    else:
-        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 / 'reports' / path, "wb") as f:
-        f.write(report.index.to_bytes(8, 'big'))
-        f.write(buf)
-    if refresh_heads:
-        set_head(workflow, path, base_path)
-    return report.index
-
-
-def load_report(path: str | Path, base_path: str | Path) -> Report | None:
-    base_path = Path(base_path)
-    path = base_path / 'reports' / path
-
-    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
-        report.index = index
-        return report
-
-
 def find_report(
     workflow: str, base_path: str | Path = get_config_value("data", Path)
 ) -> Report | None:
@@ -236,6 +180,26 @@ def revoke_report(workflow: str, report: Report | None, base_path: str | Path):
                            refresh_heads=True)
 
 
+def get_report_by_index(
+    index: int, base_path: str | Path = get_config_value("data", Path)
+) -> Report | None:
+    try:
+        path = query_index("report", base_path, index)
+        return load_report(path, base_path)
+    except:
+        raise
+        return None
+
+
+def get_head(workflow: str, base_path: str | Path) -> Path | None:
+    return get_heads(base_path).get(workflow, None)
+
+
+#########################################################################
+##                           Basic Write API                           ##
+#########################################################################
+
+
 def set_head(workflow: str, path: Path, base_path: str | Path):
     base_path = Path(base_path)
     base_path.mkdir(parents=True, exist_ok=True)
@@ -249,24 +213,44 @@ def set_head(workflow: str, path: Path, base_path: str | Path):
         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 save_report(workflow: str,
+                report: Report,
+                base_path: str | Path,
+                overwrite: bool = False,
+                refresh_heads: bool = True) -> int:
+    if workflow.startswith("cfg:"):
+        return save_config_key_history(workflow[4:], report, base_path)
 
-def get_heads(base_path: str | Path) -> Path | None:
+    logger.debug(
+        f'Saving report for "{workflow}", {report.in_spec=}, {report.bad_data=}, {report.fully_calibrated=}'
+    )
     base_path = Path(base_path)
     try:
-        with open(base_path / "heads", "rb") as f:
-            heads = pickle.load(f)
-        return heads
+        buf = lzma.compress(pickle.dumps(report))
     except:
-        return {}
+        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 / 'reports' / path, "rb") as f:
+            index = int.from_bytes(f.read(8), 'big')
+        report.index = index
+    else:
+        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 / 'reports' / path, "wb") as f:
+        f.write(report.index.to_bytes(8, 'big'))
+        f.write(buf)
+    if refresh_heads:
+        set_head(workflow, path, base_path)
+    return report.index
 
 
 def create_index(name: str,
@@ -302,27 +286,6 @@ def create_index(name: str,
     return index
 
 
-@lru_cache(maxsize=4096)
-def query_index(name: str, base_path: str | Path, index: int):
-    path = Path(base_path) / "index" / name
-    width = int(path.with_suffix('.width').read_text())
-
-    with path.with_suffix('.idx').open("r") as f:
-        f.seek(index * (width + 1))
-        context = f.read(width)
-    return context.rstrip()
-
-
-def get_report_by_index(
-    index: int, base_path: str | Path = get_config_value("data", Path)
-) -> Report | None:
-    try:
-        path = query_index("report", base_path, index)
-        return load_report(path, base_path)
-    except:
-        return None
-
-
 def save_item(item, data_path):
     salt = 0
     buf = pickle.dumps(item)
@@ -345,10 +308,244 @@ def save_item(item, data_path):
     return str(item_id)
 
 
+def save_config_key_history(key: str, report: Report,
+                            base_path: str | Path) -> int:
+    global __current_config_cache
+    base_path = Path(base_path) / 'state'
+    base_path.mkdir(parents=True, exist_ok=True)
+
+    if __current_config_cache is None:
+        if (base_path / 'parameters.pkl').exists():
+            with open(base_path / 'parameters.pkl', 'rb') as f:
+                __current_config_cache = pickle.load(f)
+        else:
+            __current_config_cache = {}
+
+    __current_config_cache[
+        key] = report.data, report.calibrated_time, report.checked_time
+
+    with open(base_path / 'parameters.pkl', 'wb') as f:
+        pickle.dump(__current_config_cache, f)
+    return 0
+
+
+#########################################################################
+##                            Basic Read API                           ##
+#########################################################################
+
+
+def load_report(path: str | Path, base_path: str | Path) -> Report | None:
+    if isinstance(base_path, str) and base_path.startswith('ssh '):
+        with SSHClient() as client:
+            cfg, base_path = _pase_ssh_config(base_path[4:])
+            client.load_system_host_keys()
+            client.connect(**cfg)
+            return load_report_from_scp(path, base_path, client)
+
+    base_path = Path(base_path)
+    if zipfile.is_zipfile(base_path):
+        return load_report_from_zipfile(path, base_path)
+
+    path = base_path / 'reports' / path
+
+    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
+        report.index = index
+        return report
+
+
+def get_heads(base_path: str | Path) -> Path | None:
+    if isinstance(base_path, str) and base_path.startswith('ssh '):
+        with SSHClient() as client:
+            cfg, base_path = _pase_ssh_config(base_path[4:])
+            client.load_system_host_keys()
+            client.connect(**cfg)
+            return get_heads_from_scp(base_path, client)
+
+    base_path = Path(base_path)
+    if zipfile.is_zipfile(base_path):
+        return get_heads_from_zipfile(base_path)
+    try:
+        with open(base_path / "heads", "rb") as f:
+            heads = pickle.load(f)
+        return heads
+    except:
+        return {}
+
+
+@lru_cache(maxsize=4096)
+def query_index(name: str, base_path: str | Path, index: int):
+    if isinstance(base_path, str) and base_path.startswith('ssh '):
+        with SSHClient() as client:
+            cfg, base_path = _pase_ssh_config(base_path[4:])
+            client.load_system_host_keys()
+            client.connect(**cfg)
+            return query_index_from_scp(name, base_path, client, index)
+
+    base_path = Path(base_path)
+    if zipfile.is_zipfile(base_path):
+        return query_index_from_zipfile(name, base_path, index)
+    path = Path(base_path) / "index" / name
+    width = int(path.with_suffix('.width').read_text())
+
+    with path.with_suffix('.idx').open("r") as f:
+        f.seek(index * (width + 1))
+        context = f.read(width)
+    return context.rstrip()
+
+
 @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))
-    return cfg
+def load_item(id, base_path):
+    if isinstance(base_path, str) and base_path.startswith('ssh '):
+        with SSHClient() as client:
+            cfg, base_path = _pase_ssh_config(base_path[4:])
+            client.load_system_host_keys()
+            client.connect(**cfg)
+            buf = load_item_buf_from_scp(id, base_path, client)
+    else:
+        base_path = Path(base_path)
+        if zipfile.is_zipfile(base_path):
+            buf = load_item_buf_from_zipfile(id, base_path)
+        else:
+            path = Path(base_path) / 'items' / id
+            with open(path, 'rb') as f:
+                buf = f.read()
+    item = pickle.loads(lzma.decompress(buf))
+    return item
+
+
+def find_config_key_history(key: str, base_path: str | Path) -> Report | None:
+    global __current_config_cache
+    base_path = Path(base_path) / 'state'
+    if __current_config_cache is None:
+        if (base_path / 'parameters.pkl').exists():
+            with open(base_path / 'parameters.pkl', 'rb') as f:
+                __current_config_cache = pickle.load(f)
+        else:
+            __current_config_cache = {}
+
+    if key in __current_config_cache:
+        value, calibrated_time, checked_time = __current_config_cache.get(
+            key, None)
+        report = Report(
+            workflow=f'cfg:{key}',
+            bad_data=False,
+            in_spec=True,
+            fully_calibrated=True,
+            parameters={key: value},
+            data=value,
+            calibrated_time=calibrated_time,
+            checked_time=checked_time,
+        )
+        return report
+    return None
+
+
+#########################################################################
+##                            Zipfile support                          ##
+#########################################################################
+
+
+def load_report_from_zipfile(path: str | Path,
+                             base_path: str | Path) -> Report | None:
+    path = Path(path)
+    with zipfile.ZipFile(base_path) as zf:
+        path = '/'.join(path.parts)
+        with zf.open(f"{base_path.stem}/reports/{path}") as f:
+            index = int.from_bytes(f.read(8), 'big')
+            report = pickle.loads(lzma.decompress(f.read()))
+            report.base_path = base_path
+            report.index = index
+            return report
+
+
+def get_heads_from_zipfile(base_path: str | Path) -> Path | None:
+    with zipfile.ZipFile(base_path) as zf:
+        with zf.open(f"{base_path.stem}/heads") as f:
+            heads = pickle.load(f)
+    return heads
+
+
+def query_index_from_zipfile(name: str, base_path: str | Path, index: int):
+    with zipfile.ZipFile(base_path) as zf:
+        with zf.open(f"{base_path.stem}/index/{name}.width") as f:
+            width = int(f.read().decode())
+        with zf.open(f"{base_path.stem}/index/{name}.idx") as f:
+            f.seek(index * (width + 1))
+            context = f.read(width).decode()
+    return context.rstrip()
+
+
+def load_item_buf_from_zipfile(id, base_path):
+    with zipfile.ZipFile(base_path) as zf:
+        with zf.open(f"{base_path.stem}/items/{id}") as f:
+            return f.read()
+
+
+#########################################################################
+##                             SCP support                             ##
+#########################################################################
+
+
+def _pase_ssh_config(config: str):
+    config = config.split()
+    base_path = ' '.join(config[4:])
+    return {
+        'hostname': config[0],
+        'port': int(config[1]),
+        'username': config[2],
+        'key_filename': config[3]
+    }, Path(base_path)
+
+
+def load_report_from_scp(path: str | Path, base_path: Path,
+                         client: SSHClient) -> Report:
+    try:
+        path = Path(path)
+        with client.open_sftp() as sftp:
+            with sftp.open(str(Path(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 = path
+                report.index = index
+                return report
+    except SSHException:
+        raise ValueError(f"Can't load report from {path}")
+
+
+def get_heads_from_scp(base_path: Path, client: SSHClient) -> Path | None:
+    try:
+        with client.open_sftp() as sftp:
+            with sftp.open(str(Path(base_path) / 'heads'), 'rb') as f:
+                heads = pickle.load(f)
+        return heads
+    except SSHException:
+        return None
+
+
+def query_index_from_scp(name: str, base_path: Path, client: SSHClient,
+                         index: int):
+    try:
+        with client.open_sftp() as sftp:
+            s = str(Path(base_path) / 'index' / f'{name}.width')
+            with sftp.open(s, 'rb') as f:
+                width = int(f.read().decode())
+            with sftp.open(str(base_path / 'index' / f'{name}.idx'),
+                           'rb') as f:
+                f.seek(index * (width + 1))
+                context = f.read(width).decode()
+        return context.rstrip()
+    except SSHException:
+        return None
+
+
+def load_item_buf_from_scp(id: str, base_path: Path, client: SSHClient):
+    try:
+        with client.open_sftp() as sftp:
+            with sftp.open(str(Path(base_path) / 'items' / str(id)),
+                           'rb') as f:
+                return f.read()
+    except SSHException:
+        return None

qulab/utils.py

@@ -42,7 +42,7 @@ def _unix_detach_with_tmux_or_screen(executable_path):
             "-d",
             "-s",
             session_name,
-            safe_path + " ; tmux wait-for -S finished",  # 等待命令结束
+            executable_path + " ; tmux wait-for -S finished",  # 等待命令结束
             ";",
             "tmux",
             "wait-for",
@@ -55,7 +55,7 @@ def _unix_detach_with_tmux_or_screen(executable_path):
 
     # 尝试 screen
     elif _check_command_exists("screen"):
-        command = ["screen", "-dmS", session_name, safe_path]
+        command = ["screen", "-dmS", session_name, executable_path]
         subprocess.Popen(command, start_new_session=True)
         click.echo(f"已启动 screen 会话: {session_name}")
         click.echo(f"你可以使用 `screen -r {session_name}` 来查看输出")
@@ -66,18 +66,18 @@ def _unix_detach_with_tmux_or_screen(executable_path):
 
 def run_detached_with_terminal(executable_path):
     """回退到带终端窗口的方案"""
-    safe_path = shlex.quote(executable_path)
     if sys.platform == 'win32':
         _windows_start(executable_path)
     elif sys.platform == 'darwin':
-        script = f'tell app "Terminal" to do script "{safe_path}"'
+        script = f'tell app "Terminal" to do script "{executable_path}"'
         subprocess.Popen(["osascript", "-e", script], start_new_session=True)
     else:
         try:
-            subprocess.Popen(["gnome-terminal", "--", "sh", "-c", safe_path],
-                             start_new_session=True)
+            subprocess.Popen(
+                ["gnome-terminal", "--", "sh", "-c", executable_path],
+                start_new_session=True)
         except FileNotFoundError:
-            subprocess.Popen(["xterm", "-e", safe_path],
+            subprocess.Popen(["xterm", "-e", executable_path],
                              start_new_session=True)
 
 

qulab/version.py

@@ -1 +1 @@
-__version__ = "2.7.18"
+__version__ = "2.8.0"

{qulab-2.7.18.dist-info → qulab-2.8.0.dist-info}/METADATA

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

{qulab-2.7.18.dist-info → qulab-2.8.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
 qulab/__init__.py,sha256=RZme5maBSMZpP6ckXymqZpo2sRYttwEpTYCIzIvys1c,292
 qulab/__main__.py,sha256=FL4YsGZL1jEtmcPc5WbleArzhOHLMsWl7OH3O-1d1ss,72
 qulab/dicttree.py,sha256=ZoSJVWK4VMqfzj42gPb_n5RqLlM6K1Me0WmLIfLEYf8,14195
-qulab/fun.cp311-win_amd64.pyd,sha256=6RxYFz6SnyWLym6Rrq0e6W5vl3AaPXgwzyb6YjDzc80,31744
+qulab/fun.cp311-win_amd64.pyd,sha256=3uplLogKifP8ydqTn5YcrV66KWQ7C9pDdbS23CrkVlY,31744
 qulab/typing.py,sha256=PRtwbCHWY2ROKK8GHq4Bo8llXrIGo6xC73DrQf7S9os,71
-qulab/utils.py,sha256=kSy_tQRLDdlMwk7XhGhg75JadNHbDkau5vYcfOlJG_4,3088
-qulab/version.py,sha256=xLneP_cqIForMj5AICyQrp13un8yGC7zOY4cjyKywXk,22
+qulab/utils.py,sha256=65N2Xj7kqRsQ4epoLNY6tL-i5ts6Wk8YuJYee3Te6zI,3077
+qulab/version.py,sha256=HoslYmXXy3WAQMEXd5jNDwMD2rL7bVPI5DzutSN5GNc,21
 qulab/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/cli/commands.py,sha256=6xd2eYw32k1NmfAuYSu__1kaP12Oz1QVqwbkYXdWno4,588
 qulab/cli/config.py,sha256=7h3k0K8FYHhI6LVWt8BoDdKrX2ApFDBAUAUuXhHwst4,3799
 qulab/executor/__init__.py,sha256=LosPzOMaljSZY1thy_Fxtbrgq7uubJszMABEB7oM7tU,101
-qulab/executor/cli.py,sha256=z8W1RivKdABQSOGy2viNUvG73QvOBpE9gSKjw45vSVA,9794
-qulab/executor/load.py,sha256=omD2aklKZnHOosahI-Vs6sQkGdn4U9PgnDIAbrEOhi0,17786
+qulab/executor/cli.py,sha256=8d-8bRWZ5lmsMtjASsl1zu1rV-syeAESMNVthvIQxlo,10018
+qulab/executor/load.py,sha256=YndvzagvWR8Sg6WHZ-gP-Of0FrFOyh_E_a3VXsjDf1Q,17502
 qulab/executor/schedule.py,sha256=0BV5LGxhqdIlGwW6-o5_5mljAtdtL1La8EDNBFi8pzU,18585
-qulab/executor/storage.py,sha256=gI6g28BmKKEZ_Pl-hFwvpiOj3mF8Su-yjj3hfMXs1VY,11630
+qulab/executor/storage.py,sha256=2YWUxYis8QlYLhzvvwoS2Wmyb9UYaojEh6X20ICePWI,19014
 qulab/executor/template.py,sha256=bKMoOBPfa3XMgTfGHQK6pDTswH1vcIjnopaWE3UKpP0,7726
 qulab/executor/transform.py,sha256=BDx0c4nqTHMAOLVqju0Ydd91uxNm6EpVIfssjZse0bI,2284
 qulab/executor/utils.py,sha256=l_b0y2kMwYKyyXeFtoblPYwKNU-wiFQ9PMo9QlWl9wE,6213
@@ -97,9 +97,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.18.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
-qulab-2.7.18.dist-info/METADATA,sha256=ftNypm4S-GR5LeN2SHGHdrAlv0dvHksDaQH_XwPoFo8,3804
-qulab-2.7.18.dist-info/WHEEL,sha256=KJXh1V8Kwbv4sLWZhe-NnXz7pUnJH10x-MhKeMsQYvA,101
-qulab-2.7.18.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
-qulab-2.7.18.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-qulab-2.7.18.dist-info/RECORD,,
+qulab-2.8.0.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
+qulab-2.8.0.dist-info/METADATA,sha256=7GHqBOgAMQ_zxJaGPbsc6AbwGMQ7IObgjC9Dh5k7ggM,3803
+qulab-2.8.0.dist-info/WHEEL,sha256=sth_4wOlmB4B7KwCBgmeM0_a5vgcRqkZDHCDdXAQZRc,101
+qulab-2.8.0.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
+qulab-2.8.0.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+qulab-2.8.0.dist-info/RECORD,,

{qulab-2.7.18.dist-info → qulab-2.8.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (76.1.0)
 Root-Is-Purelib: false
 Tag: cp311-cp311-win_amd64