QuLab 2.7.19__cp310-cp310-macosx_10_9_universal2.whl → 2.9.0__cp310-cp310-macosx_10_9_universal2.whl

qulab/__init__.py

@@ -1,5 +1,6 @@
 from .executor.storage import find_report
 from .executor.storage import get_report_by_index as get_report
+from .executor.template import VAR
 from .executor.utils import debug_analyze
 from .scan import Scan, get_record, load_record, lookup, lookup_list
 from .version import __version__

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/storage.py

@@ -1,15 +1,42 @@
 import hashlib
 import lzma
 import pickle
+import re
 import uuid
+import zipfile
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta
 from functools import lru_cache
 from pathlib import Path
 from typing import Any, Literal
+from urllib.parse import parse_qs
 
 from loguru import logger
 
+try:
+    from paramiko import SSHClient
+    from paramiko.ssh_exception import SSHException
+except:
+    import warnings
+
+    warnings.warn("Can't import paramiko, ssh support will be disabled.")
+
+    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
+
+    class SSHException(Exception):
+        pass
+
+
 from ..cli.config import get_config_value
 
 __current_config_cache = None
@@ -31,7 +58,7 @@ class Report():
     index: int = -1
     previous_path: Path | None = field(default=None, repr=False)
     heads: dict[str, Path] = field(default_factory=dict, repr=False)
-    base_path: Path | None = field(default=None, repr=False)
+    base_path: str | 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)
@@ -43,7 +70,7 @@ class Report():
             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:
@@ -101,6 +128,17 @@ class Report():
             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
 
@@ -113,106 +151,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:
@@ -252,6 +190,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)
@@ -265,24 +223,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,
@@ -318,27 +296,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)
@@ -361,10 +318,290 @@ 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 = parse_ssh_uri(base_path)
+            remote_base_path = cfg.pop('remote_file_path')
+            client.load_system_host_keys()
+            client.connect(**cfg)
+            report = load_report_from_scp(path, remote_base_path, client)
+            report.base_path = base_path
+            return report
+
+    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 = parse_ssh_uri(base_path)
+            remote_base_path = cfg.pop('remote_file_path')
+            client.load_system_host_keys()
+            client.connect(**cfg)
+            return get_heads_from_scp(remote_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 = parse_ssh_uri(base_path)
+            remote_base_path = cfg.pop('remote_file_path')
+            client.load_system_host_keys()
+            client.connect(**cfg)
+            return query_index_from_scp(name, remote_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 = parse_ssh_uri(base_path)
+            remote_base_path = cfg.pop('remote_file_path')
+            client.load_system_host_keys()
+            client.connect(**cfg)
+            buf = load_item_buf_from_scp(id, remote_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 parse_ssh_uri(uri):
+    """
+    解析 SSH URI 字符串，返回包含连接参数和路径的字典。
+    
+    格式：ssh://[{username}[:{password}]@]{host}[:{port}][?key_filename={key_path}][/{remote_file_path}]
+
+    返回示例：
+    {
+        "username": "user",
+        "password": "pass",
+        "host": "example.com",
+        "port": 22,
+        "key_filename": "/path/to/key",
+        "remote_file_path": "/data/file.txt"
+    }
+    """
+    pattern = re.compile(
+        r"^ssh://"  # 协议头
+        r"(?:([^:@/]+))(?::([^@/]+))?@?"  # 用户名和密码（可选）
+        r"([^:/?#]+)"  # 主机名（必须）
+        r"(?::(\d+))?"  # 端口（可选）
+        r"(/?[^?#]*)?"  # 远程路径（可选）
+        r"(?:\?([^#]+))?"  # 查询参数（如 key_filename）
+        r"$",
+        re.IGNORECASE)
+
+    match = pattern.match(uri)
+    if not match:
+        raise ValueError(f"Invalid SSH URI format: {uri}")
+
+    # 提取分组
+    username, password, host, port, path, query = match.groups()
+
+    # 处理查询参数
+    key_filename = None
+    if query:
+        params = parse_qs(query)
+        key_filename = params.get("key_filename", [None])[0]  # 取第一个值
+
+    # 清理路径开头的斜杠
+    remote_file_path = path
+
+    return {
+        "username": username,
+        "password": password,
+        "hostname": host,
+        "port": int(port) if port else 22,  # 默认端口 22
+        "key_filename": key_filename,
+        "remote_file_path": remote_file_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.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(Path(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/executor/template.py

@@ -8,6 +8,12 @@ import string
 import textwrap
 from typing import Any
 
+_notset = object()
+
+
+def VAR(name: str, /, *, default: Any = _notset) -> Any:
+    return name
+
 
 def encode_mapping(mapping):
     mapping_bytes = lzma.compress(pickle.dumps(mapping))
@@ -68,26 +74,67 @@ class TemplateVarExtractor(ast.NodeVisitor):
     def visit_Call(self, node):
         if isinstance(node.func, ast.Name) and node.func.id == 'VAR':
             arg = node.args[0]
-            if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
-                if arg.value not in self.mapping:
-                    raise TemplateKeyError(
-                        f"The variable '{arg.value}' is not provided in mapping. {self.fname}:{node.lineno}"
+            if not isinstance(arg, ast.Constant) or not isinstance(
+                    arg.value, str):
+                raise SyntaxError(
+                    f"Argument of VAR function must be a string. {self.fname}:{node.lineno}"
+                )
+            if len(node.args) != 1:
+                raise SyntaxError(
+                    f"VAR function only accept one argument. {self.fname}:{node.lineno}"
+                )
+            default = _notset
+            for k in node.keywords:
+                if k.arg == 'default':
+                    pass
+                    # if isinstance(k.value, ast.Constant):
+                    #     # default = k.value.value
+                    #     default = k.value
+                    # else:
+                    #     default = k.value
+                    #     # raise SyntaxError(
+                    #     #     f"Argument of 'default' must be a constant. {self.fname}:{node.lineno}"
+                    #     # )
+                else:
+                    raise SyntaxError(
+                        f"VAR function only accept keyword argument 'default'. {self.fname}:{node.lineno}"
                     )
-                self.variables.add(arg.value)
+
+            if default is _notset:
                 # new_node = ast.Subscript(value=ast.Name(id="__VAR",
                 #                                         ctx=ast.Load()),
                 #                          slice=ast.Constant(value=arg.value),
                 #                          ctx=ast.Load())
-                # ast.fix_missing_locations(new_node)
-                # new_source = ast.unparse(new_node)
+                if arg.value not in self.mapping:
+                    raise TemplateKeyError(
+                        f"The variable '{arg.value}' is not provided in mapping. {self.fname}:{node.lineno}"
+                    )
                 self.replacements[(node.lineno, node.end_lineno,
                                    node.col_offset,
                                    node.end_col_offset)] = ('VAR', arg.value,
                                                             None, None)
             else:
-                raise SyntaxError(
-                    f"Argument of VAR function must be a string. {self.fname}:{node.lineno}"
-                )
+                # new_node = ast.Call(
+                #     func=ast.Attribute(value=ast.Name(id='__VAR',
+                #                                       ctx=ast.Load()),
+                #                        attr='get',
+                #                        ctx=ast.Load()),
+                #     args=[ast.Constant(value=arg.value)],
+                #     keywords=[
+                #         ast.keyword(arg='default',
+                #                     value=value)
+                #     ],
+                #     ctx=ast.Load())
+                self.replacements[(node.lineno, node.end_lineno,
+                                   node.col_offset,
+                                   node.end_col_offset)] = ('VAR', arg.value,
+                                                            None, None)
+            # ast.fix_missing_locations(new_node)
+            # new_source = ast.unparse(new_node)
+            # print(new_source)
+
+            self.variables.add(arg.value)
+
         self.generic_visit(node)
 
     def _process_string(self, s: str, lineno: int, col_offset: int,
@@ -160,8 +207,24 @@ def inject_mapping(source: str, mapping: dict[str, Any],
                 lines_offset[end_lineno - 1] += len(
                     lines[end_lineno - 1]) - length_of_last_line
         else:
-            pattern = re.compile(r'VAR\s*\(\s*(["\'])(\w+)\1\s*\)')
-            replacement = f'__VAR_{hash_str}' + r'[\1\2\1]'
+            pattern = re.compile(
+                r'VAR\s*\(\s*'         # VAR(
+                r'(["\'])(\w+)\1'      # 第一个参数（引号包裹的变量名）
+                r'(?:\s*,\s*(.*?))?'   # 可选的其他参数
+                r'\s*\)',              # 闭合括号
+                re.DOTALL              # 允许.匹配换行符
+            ) # yapf: disable
+
+            def replacement(match):
+                quote = match.group(1)
+                var_name = match.group(2)
+                extra_args = match.group(3)
+                base = f'__VAR_{hash_str}'
+                if extra_args is not None:
+                    return f'{base}.get({quote}{var_name}{quote}, {extra_args})'
+                else:
+                    return f'{base}[{quote}{var_name}{quote}]'
+
             new_content = re.sub(pattern, replacement, content)
 
             if lineno == end_lineno:
@@ -172,7 +235,7 @@ def inject_mapping(source: str, mapping: dict[str, Any],
                 lines[lineno - 1] = head + new_content[:-1]
                 for i in range(lineno, end_lineno - 1):
                     lines[i] = ''
-                lines[end_lineno - 1] = ']' + tail
+                lines[end_lineno - 1] = new_content[-1] + tail
                 lines_offset[end_lineno - 1] += len(
                     lines[end_lineno - 1]) - length_of_last_line
 

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.19"
+__version__ = "2.9.0"

{qulab-2.7.19.dist-info → qulab-2.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: QuLab
-Version: 2.7.19
+Version: 2.9.0
 Summary: contral instruments and manage data
 Author-email: feihoo87 <feihoo87@gmail.com>
 Maintainer-email: feihoo87 <feihoo87@gmail.com>
@@ -44,6 +44,7 @@ Requires-Dist: watchdog>=4.0.0
 Requires-Dist: waveforms>=1.9.4
 Provides-Extra: full
 Requires-Dist: uvloop>=0.19.0; extra == "full"
+Dynamic: license-file
 
 # QuLab
 [![View build status](https://travis-ci.org/feihoo87/QuLab.svg?branch=master)](https://travis-ci.org/feihoo87/QuLab)

{qulab-2.7.19.dist-info → qulab-2.9.0.dist-info}/RECORD

@@ -1,19 +1,19 @@
-qulab/__init__.py,sha256=KJcUcZ5qXY6wlAoirzK_B-dgtDjsLmOE671v3gcXO_c,286
+qulab/__init__.py,sha256=JZ3bn_kTVlnY-P8JXQ5xEdViieFXqfxX8ReLuiiXIpo,321
 qulab/__main__.py,sha256=fjaRSL_uUjNIzBGNgjlGswb9TJ2VD5qnkZHW3hItrD4,68
 qulab/dicttree.py,sha256=tRRMpGZYVOLw0TEByE3_2Ss8FdOmzuGL9e1DWbs8qoY,13684
-qulab/fun.cpython-310-darwin.so,sha256=JNmhMFDYBLA9A5KZ-ozH7Bl8z9GpyYoy2BgVjKDszC4,126864
+qulab/fun.cpython-310-darwin.so,sha256=I9BhLrc8TSk1d9M3t7Le6uaG1j4bGaNyDkTAyuhNNZo,126864
 qulab/typing.py,sha256=vg62sGqxuD9CI5677ejlzAmf2fVdAESZCQjAE_xSxPg,69
-qulab/utils.py,sha256=_0gm0sHwwIhk0tYRCLu4oNaS6Tt8meGWt6byu7Kk95Y,2993
-qulab/version.py,sha256=l3aREioriZeXEjFmLR4Dbu7Nj408gevOUOElKwDjjD4,22
+qulab/utils.py,sha256=BdLdlfjpe6m6gSeONYmpAKTTqxDaYHNk4exlz8kZxTg,2982
+qulab/version.py,sha256=a31Mxt9ZbwomFaywnjMS--InOBZRSD7ltY06SX9P5q0,21
 qulab/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 qulab/cli/commands.py,sha256=tgDIkkeIoasQXAifJZ6NU8jDgpNgb2a-B0C4nF0evrE,559
 qulab/cli/config.py,sha256=Ei7eSYnbwPPlluDnm8YmWONYiI4g7WtvlZGQdr1Z6vo,3688
 qulab/executor/__init__.py,sha256=LosPzOMaljSZY1thy_Fxtbrgq7uubJszMABEB7oM7tU,101
-qulab/executor/cli.py,sha256=z8W1RivKdABQSOGy2viNUvG73QvOBpE9gSKjw45vSVA,9794
+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=jFUXYcBFyH2vVzrSzmXtyLtEgIMRczfk27Yb95pV5JM,12217
-qulab/executor/template.py,sha256=1c7xd0U82fLaqb8O0NQIVVd7aRLuCZNT11-heFw2n9Q,7540
+qulab/executor/storage.py,sha256=OA_XMDoFDfPZCU89caf9-VZ3D6qaWib8MpJno10KUfc,20770
+qulab/executor/template.py,sha256=BhNP8GrTk0pCK3GwijI08Q2jmYPbLi_7A5XWZXhCtUo,10123
 qulab/executor/transform.py,sha256=BDx0c4nqTHMAOLVqju0Ydd91uxNm6EpVIfssjZse0bI,2284
 qulab/executor/utils.py,sha256=l_b0y2kMwYKyyXeFtoblPYwKNU-wiFQ9PMo9QlWl9wE,6213
 qulab/monitor/__init__.py,sha256=nTHelnDpxRS_fl_B38TsN0njgq8eVTEz9IAnN3NbDlM,42
@@ -97,9 +97,9 @@ qulab/visualization/plot_seq.py,sha256=UWTS6p9nfX_7B8ehcYo6UnSTUCjkBsNU9jiOeW2ca
 qulab/visualization/qdat.py,sha256=ZeevBYWkzbww4xZnsjHhw7wRorJCBzbG0iEu-XQB4EA,5735
 qulab/visualization/rot3d.py,sha256=lMrEJlRLwYe6NMBlGkKYpp_V9CTipOAuDy6QW_cQK00,734
 qulab/visualization/widgets.py,sha256=6KkiTyQ8J-ei70LbPQZAK35wjktY47w2IveOa682ftA,3180
-qulab-2.7.19.dist-info/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
-qulab-2.7.19.dist-info/METADATA,sha256=5Xnc4iYsS7_SHRxyEwF9nXTeK9D6d4IZQ8pvWEsPMwc,3699
-qulab-2.7.19.dist-info/WHEEL,sha256=PolFmPkBRqOxJCMvmNEJhcMPAgrWNQIyPvTInzN4IZk,114
-qulab-2.7.19.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
-qulab-2.7.19.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
-qulab-2.7.19.dist-info/RECORD,,
+qulab-2.9.0.dist-info/licenses/LICENSE,sha256=PRzIKxZtpQcH7whTG6Egvzl1A0BvnSf30tmR2X2KrpA,1065
+qulab-2.9.0.dist-info/METADATA,sha256=gci3kQAblFeB_opSNNDQhNyQAShjlv1NnEWYxGcFlqI,3720
+qulab-2.9.0.dist-info/WHEEL,sha256=RRryqyZoeot9BN8ld5DvkJ-s2j9ZJzBwSMHgoE8p4Pg,114
+qulab-2.9.0.dist-info/entry_points.txt,sha256=b0v1GXOwmxY-nCCsPN_rHZZvY9CtTbWqrGj8u1m8yHo,45
+qulab-2.9.0.dist-info/top_level.txt,sha256=3T886LbAsbvjonu_TDdmgxKYUn939BVTRPxPl9r4cEg,6
+qulab-2.9.0.dist-info/RECORD,,

{qulab-2.7.19.dist-info → qulab-2.9.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (76.0.0)
+Generator: setuptools (77.0.3)
 Root-Is-Purelib: false
 Tag: cp310-cp310-macosx_10_9_universal2