QuLab 2.7.19__cp310-cp310-win_amd64.whl → 2.8.0__cp310-cp310-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/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
@@ -43,7 +60,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 +118,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 +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:
@@ -252,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)
@@ -265,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,
@@ -318,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)
@@ -361,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.19"
+__version__ = "2.8.0"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: QuLab
-Version: 2.7.19
+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.19.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.cp310-win_amd64.pyd,sha256=oUlIAuuUIquUS0LoxQs8OWRxq6VIKkj4u_GIR_CtalU,31744
+qulab/fun.cp310-win_amd64.pyd,sha256=IFR7znN7dCxfNQ3OHZgTsi1G8b8cSlyLacwV_oGBWnI,31744
 qulab/typing.py,sha256=PRtwbCHWY2ROKK8GHq4Bo8llXrIGo6xC73DrQf7S9os,71
-qulab/utils.py,sha256=kSy_tQRLDdlMwk7XhGhg75JadNHbDkau5vYcfOlJG_4,3088
-qulab/version.py,sha256=l3aREioriZeXEjFmLR4Dbu7Nj408gevOUOElKwDjjD4,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/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/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.19.dist-info/LICENSE,sha256=b4NRQ-GFVpJMT7RuExW3NwhfbrYsX7AcdB7Gudok-fs,1086
-qulab-2.7.19.dist-info/METADATA,sha256=De5Wd5mlNaRcr3jnjjS0R2O-_6tfd3Jj-4slwKIXmIc,3804
-qulab-2.7.19.dist-info/WHEEL,sha256=H5gvOYEhGgVYizXMDNmO6CnZIviGx48geV3Lbzu7OZg,101
-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.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=H72wNgFePEN0L06A2Z11ydRFbMa6Lsr93VFntInNpxE,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.19.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: cp310-cp310-win_amd64