cfquant 0.2.61__tar.gz → 0.2.63__tar.gz

{cfquant-0.2.61 → cfquant-0.2.63}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.61
+Version: 0.2.63
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8
@@ -283,6 +283,8 @@ print(result["status"], result["message"])
 
 `version_info(include_remote=False)` 只查询本地版本；`updates.check(force=True)` 只检查更新。按需更新也识别同版本号的安装包变化，首次安装包哈希未知时会执行一次更新以建立记录。真正需要更新时，默认要求先关闭相关 QMT；也可显式传入 `auto_close_qmt=True` 允许自动关闭。`restart=False` 可留待调用方重启。部分 QMT 部署失败返回 `update_incomplete`，已安装但尚未重启返回 `restart_required`；执行更新失败会抛出 `ManagementError`。
 
+外部程序复用绑定时的 `runtime` 对象，直接调用 `runtime.recover_strategy("YOUR_ACCOUNT_ID", account_type="STOCK")` 即可检测并尝试恢复已停止的 QMT 托管策略。本地托管实例由 SDK 自动读取管理凭据。也支持 `runtime.accounts.recover_strategy(...)` 和鉴权后的 `POST /api/qmt/strategies/recover`。返回值区分已提交启动、模型运行和通信确认，具体条件及示例见 [策略恢复接口](docs/第三方项目管理SDK.md#外部程序恢复-qmt-托管策略)。
+
 模拟／实盘参数需与实际账号一致。完整的启动策略、更新接口、重复绑定行为与错误处理见 [第三方项目管理 SDK](docs/第三方项目管理SDK.md)。
 
 ## 从 `xtquant` 迁移到 `cfquant`

{cfquant-0.2.61 → cfquant-0.2.63}/README.md

@@ -258,6 +258,8 @@ print(result["status"], result["message"])
 
 `version_info(include_remote=False)` 只查询本地版本；`updates.check(force=True)` 只检查更新。按需更新也识别同版本号的安装包变化，首次安装包哈希未知时会执行一次更新以建立记录。真正需要更新时，默认要求先关闭相关 QMT；也可显式传入 `auto_close_qmt=True` 允许自动关闭。`restart=False` 可留待调用方重启。部分 QMT 部署失败返回 `update_incomplete`，已安装但尚未重启返回 `restart_required`；执行更新失败会抛出 `ManagementError`。
 
+外部程序复用绑定时的 `runtime` 对象，直接调用 `runtime.recover_strategy("YOUR_ACCOUNT_ID", account_type="STOCK")` 即可检测并尝试恢复已停止的 QMT 托管策略。本地托管实例由 SDK 自动读取管理凭据。也支持 `runtime.accounts.recover_strategy(...)` 和鉴权后的 `POST /api/qmt/strategies/recover`。返回值区分已提交启动、模型运行和通信确认，具体条件及示例见 [策略恢复接口](docs/第三方项目管理SDK.md#外部程序恢复-qmt-托管策略)。
+
 模拟／实盘参数需与实际账号一致。完整的启动策略、更新接口、重复绑定行为与错误处理见 [第三方项目管理 SDK](docs/第三方项目管理SDK.md)。
 
 ## 从 `xtquant` 迁移到 `cfquant`

{cfquant-0.2.61 → cfquant-0.2.63}/cfquant/management.py

@@ -314,6 +314,17 @@ class RuntimeManager:
         """Initialize the first binding; subsequent calls upsert that binding."""
         return self.accounts.upsert(account_id, qmt_dir, _initialize=True, **options)
 
+    def recover_strategy(self, account_id=None, *, account_type=None, bridge_id=None,
+                         account_key=None, timeout=180):
+        """Recover a binding using the same managed service as initialize().
+
+        Reuse this RuntimeManager after binding accounts. Local managed services
+        automatically use home/management.key, just like account management.
+        """
+        return self.accounts.recover_strategy(account_id, account_type=account_type,
+                                             bridge_id=bridge_id, account_key=account_key,
+                                             timeout=timeout)
+
     def wait_ready(self, account_id, *, account_type="STOCK", bridge_id=None, timeout=120):
         deadline = time.monotonic() + timeout
         last = None
@@ -363,6 +374,27 @@ class AccountManager:
     def status(self, timeout=None):
         return self.runtime._request("GET", "/api/bindings/status", timeout=timeout)
 
+    def recover_strategy(self, account_id=None, *, account_type=None, bridge_id=None,
+                         account_key=None, timeout=180):
+        """Check and recover this binding's stopped managed QMT strategies.
+
+        Requires enabled strategy automation and a completed deployment. Returns
+        running/start_requested and per-target recovery states; submitting a start
+        is not confirmation that the strategy or its bridge is already running.
+        Uses the Web service, so it also works while the QMT bridge is offline.
+        """
+        body = {key: str(value).strip() for key, value in {
+            "account_id": account_id, "account_type": account_type,
+            "bridge_id": bridge_id, "account_key": account_key,
+        }.items() if value is not None}
+        if not body.get("account_id") and not body.get("account_key"):
+            raise ValueError("account_id or account_key is required")
+        if any(not value for value in body.values()):
+            raise ValueError("account selectors must not be empty")
+        if not self.runtime.attached:
+            self.runtime.status()  # Verify managed instance ownership first.
+        return self.runtime._request("POST", "/api/qmt/strategies/recover", body, timeout=timeout)
+
     def upsert(self, account_id, qmt_dir, *, account_type="STOCK", mode="ctypes",
                auto_start_qmt=False, deploy_strategy=True, strategy_autorun=True,
                live=True, auto_close_qmt=False, force=False, _initialize=False, **options):

{cfquant-0.2.61 → cfquant-0.2.63}/cfquant/qmt_component_login.py

@@ -27,7 +27,7 @@ def verify_environment(directory):
     verify_environment_isolated(directory)
 
 
-def _verify_environment_native(directory):
+def _verify_environment_native(directory, *, strategy=False):
     """Only invoked inside the native worker or the standalone login CLI."""
     try:
         from .qmt_dependencies import LOGIN_MODULES, import_login_module
@@ -38,14 +38,17 @@ def _verify_environment_native(directory):
     directory = Path(directory)
     for module in ("Qt5Core.dll", "Qt5Widgets.dll"):
         version = win32api.GetFileVersionInfo(str(directory / module), "\\")
-        if (version["FileVersionMS"], version["FileVersionLS"]) != ((5 << 16) | 6, 2 << 16):
+        if strategy:
+            if version["FileVersionMS"] >> 16 != 5:
+                raise RuntimeError("QMT 策略检测需要兼容的 Qt 5 接口，当前组件 ABI 不受支持")
+        elif (version["FileVersionMS"], version["FileVersionLS"]) != ((5 << 16) | 6, 2 << 16):
             raise RuntimeError("QMT 组件自动登录当前仅支持 Qt 5.6.2，请先适配此客户端版本")
     with (directory / "XtItClient.exe").open("rb") as stream:
         stream.seek(0x3C)
         offset = int.from_bytes(stream.read(4), "little")
         stream.seek(offset + 4)
         if int.from_bytes(stream.read(2), "little") != 0x8664:
-            raise RuntimeError("QMT 组件自动登录需要 64 位客户端")
+            raise RuntimeError("QMT 原生组件操作需要 64 位客户端")
 
 
 def auto_login(backend, password_provider, *, retry_not_ready=False, login_account=None,
@@ -132,7 +135,7 @@ def select_binding(config_path, name):
 
 
 class QtLoginBackend:
-    def __init__(self, directory, timeout=40, expected_pid=None, *, agent_extension=""):
+    def __init__(self, directory, timeout=40, expected_pid=None, *, agent_extension="", strategy=False):
         try:
             from .qmt_dependencies import import_login_module
         except ImportError:
@@ -170,7 +173,10 @@ class QtLoginBackend:
         self.pid = matches[0].pid
         if expected_pid is not None and self.pid != expected_pid:
             raise RuntimeError("QMT process changed; stopping this login attempt")
-        _verify_environment_native(directory)
+        if strategy:
+            _verify_environment_native(directory, strategy=True)
+        else:
+            _verify_environment_native(directory)
         self.mutex = win32event.CreateMutex(None, False, "Local\\CFQuantQmtComponentLogin_" + str(self.pid))
         acquired = win32event.WaitForSingleObject(self.mutex, 0)
         if acquired not in (0, 0x80):
@@ -179,13 +185,16 @@ class QtLoginBackend:
             raise RuntimeError("Another component login is already running for this QMT")
         try:
             self.session = frida.attach(self.pid)
-            readiness = self.session.create_script("rpc.exports.ready = () => ['Qt5Core.dll', 'Qt5Widgets.dll', 'LoginDialog.dll'].every(n => Process.findModuleByName(n) !== null);")
+            modules = ["Qt5Core.dll", "Qt5Widgets.dll"]
+            if not strategy:
+                modules.append("LoginDialog.dll")
+            readiness = self.session.create_script("rpc.exports.ready = () => %s.every(n => Process.findModuleByName(n) !== null);" % json.dumps(modules))
             readiness.load()
             ready = readiness.exports_sync.ready()
             readiness.unload()
             if not ready:
                 raise QmtNotReady("QMT login modules are still loading")
-            source = Path(__file__).with_name("qmt_component_agent.js").read_text(encoding="utf-8")
+            source = "" if strategy else Path(__file__).with_name("qmt_component_agent.js").read_text(encoding="utf-8")
             script = self.session.create_script(source + "\n" + agent_extension)
             script.on("message", lambda message, data: self.messages.append("agent_error") if message.get("type") == "error" else None)
             script.load()
@@ -301,6 +310,12 @@ class QtLoginBackend:
             self.api.acknowledge(str(self.failure_hwnd))
         self.failure_hwnd = None
 
+    def diagnostics(self):
+        return dict(minimized_before=self.minimized_before,
+                    foreground_before=self.foreground_before,
+                    foreground_after=self.gui.GetForegroundWindow(),
+                    script_errors=list(self.messages))
+
     def close(self):
         try:
             from .qmt_dependencies import import_login_module
@@ -332,17 +347,13 @@ def main():
     if not 1 <= args.timeout <= 120:
         parser.error("timeout must be between 1 and 120 seconds")
     row, directory = select_binding(args.config, args.binding)
-    backend = QtLoginBackend(directory, args.timeout)
+    backend = IsolatedLoginBackend(directory, args.timeout)
     try:
         backend.select_account((row.get("qmt_auto_login") or {}).get("login_account", ""), replace=True)
         def read_password():
             return getpass.getpass("QMT password (hidden): ") if args.prompt else sys.stdin.readline().rstrip("\r\n")
         result = auto_login(backend, read_password)
-        result.update(binding=args.binding, process_id=backend.pid,
-                      minimized_before=backend.minimized_before,
-                      foreground_before=backend.foreground_before,
-                      foreground_after=backend.gui.GetForegroundWindow(),
-                      script_errors=backend.messages,
+        result.update(binding=args.binding, process_id=backend.pid, **backend.diagnostics(),
                       input_method="Qt native methods; no keyboard/mouse input")
         output = json.dumps(result, ensure_ascii=False, indent=2)
         if args.report:

cfquant-0.2.63/cfquant/qmt_native_files.py

@@ -0,0 +1,145 @@
+"""Private, bounded-lifetime files for native workers; never use system TEMP."""
+import json
+import os
+from pathlib import Path
+import re
+import shutil
+import stat
+import threading
+import time
+import uuid
+
+import psutil
+
+
+_SWEEP_LOCK = threading.Lock()
+_LAST_SWEEP = {}
+_WORKER_NAME = re.compile(r"worker-[0-9a-f]{32}\Z")
+
+
+def worker_temp_root():
+    configured = os.environ.get("CFQUANT_FRIDA_TEMP_DIR")
+    if configured:
+        return Path(os.path.expandvars(configured)).expanduser().resolve()
+    runtime = os.environ.get("CFQUANT_RUNTIME_DIR")
+    if runtime:
+        return Path(os.path.expandvars(runtime)).expanduser().resolve() / "frida"
+    base = (os.environ.get("CFQUANT_HOME") or os.environ.get("CFQUANT_STATE_DIR")
+            or os.environ.get("CFQUANT_BASE_DIR") or str(Path(__file__).resolve().parents[1]))
+    return Path(os.path.expandvars(base)).expanduser().resolve() / "runtime" / "frida"
+
+
+def _process_alive(pid, created):
+    try:
+        return abs(psutil.Process(int(pid)).create_time() - float(created)) < 0.01
+    except (psutil.NoSuchProcess, ValueError, TypeError):
+        return False
+    except psutil.AccessDenied:
+        return True
+
+
+def _linked(path):
+    info = path.lstat()
+    return stat.S_ISLNK(info.st_mode) or bool(getattr(info, "st_file_attributes", 0)
+                                           & getattr(stat, "FILE_ATTRIBUTE_REPARSE_POINT", 0x400))
+
+
+def remove_worker_directory(root, directory):
+    """Delete only a direct owned child; never traverse a symlink or junction."""
+    root, directory = Path(root).resolve(), Path(directory)
+    try:
+        if (not _WORKER_NAME.fullmatch(directory.name) or _linked(directory)
+                or directory.resolve().parent != root):
+            return False
+        for parent, directories, files in os.walk(directory, followlinks=False):
+            if any(_linked(Path(parent) / name) for name in directories + files):
+                return False
+        # Keep the ownership marker until all possibly locked DLLs are gone.
+        # A partial rmtree must not make a crashed worker's files uncollectable.
+        marker = directory / "owner.json"
+        for child in directory.iterdir():
+            if child == marker:
+                continue
+            if child.is_dir():
+                shutil.rmtree(child)
+            else:
+                child.unlink()
+        marker.unlink(missing_ok=True)
+        directory.rmdir()
+        return True
+    except FileNotFoundError:
+        return True
+    except OSError:
+        return False  # Loaded DLLs can remain locked briefly; a later sweep retries.
+
+
+def sweep_worker_directories(root, *, force=False):
+    root = Path(root).resolve()
+    now = time.time()
+    with _SWEEP_LOCK:
+        if not force and now - _LAST_SWEEP.get(str(root), 0) < 60:
+            return
+        _LAST_SWEEP[str(root)] = now
+        if not root.is_dir():
+            return
+        for directory in root.iterdir():
+            try:
+                if (not _WORKER_NAME.fullmatch(directory.name) or _linked(directory)
+                        or not directory.is_dir() or now - directory.stat().st_mtime < 60):
+                    continue
+                marker = directory / "owner.json"
+                if _linked(marker):
+                    continue
+                owner = json.loads(marker.read_text(encoding="utf-8"))
+                if owner.get("format") != "cfquant-native-worker-v1":
+                    continue
+                if not isinstance(owner.get("owner_pid"), int) or not isinstance(owner.get("owner_created"), (int, float)):
+                    continue
+                child = owner.get("child_pid")
+                if child is not None and (not isinstance(child, int) or not isinstance(owner.get("child_created"), (int, float))):
+                    continue
+                # The parent's identity protects the mkdir/Popen registration window.
+                if child is None:
+                    alive = _process_alive(owner.get("owner_pid"), owner.get("owner_created"))
+                else:
+                    alive = _process_alive(child, owner.get("child_created"))
+                if not alive:
+                    remove_worker_directory(root, directory)
+            except (OSError, ValueError, TypeError, AttributeError):
+                continue
+
+
+class NativeWorkerFiles:
+    def __init__(self):
+        self.root = worker_temp_root()
+        self.root.mkdir(parents=True, exist_ok=True)
+        sweep_worker_directories(self.root)
+        self.path = self.root / ("worker-" + uuid.uuid4().hex)
+        self.path.mkdir()
+        self.owner = dict(format="cfquant-native-worker-v1", owner_pid=os.getpid(),
+                          owner_created=psutil.Process().create_time())
+        try:
+            self._save()
+        except Exception:
+            self.close()
+            raise
+
+    def _save(self):
+        marker = self.path / "owner.json"
+        pending = marker.with_suffix(".pending")
+        pending.write_text(json.dumps(self.owner), encoding="utf-8")
+        pending.replace(marker)
+
+    def register(self, pid):
+        try:
+            created = psutil.Process(pid).create_time()
+        except psutil.NoSuchProcess:
+            created = 0  # The protocol reader reports an immediate child crash.
+        self.owner.update(child_pid=pid, child_created=created)
+        self._save()
+
+    def environment(self):
+        return {name: str(self.path) for name in ("TEMP", "TMP", "TMPDIR")}
+
+    def close(self):
+        return remove_worker_directory(self.root, self.path)

{cfquant-0.2.61 → cfquant-0.2.63}/cfquant/qmt_native_worker.py

@@ -12,9 +12,11 @@ import sys
 import threading
 import time
 
+from .qmt_native_files import NativeWorkerFiles, sweep_worker_directories
+
 
 LOGIN_METHODS = frozenset(("already_logged_in", "state", "select_account", "submit",
-                           "fill", "wait_outcome", "acknowledge_failure"))
+                           "fill", "wait_outcome", "acknowledge_failure", "diagnostics"))
 STRATEGY_METHODS = frozenset(("snapshot", "start_strategy", "notices", "dismiss_notice"))
 MAX_MESSAGE = 4 * 1024 * 1024
 
@@ -40,14 +42,29 @@ class NativeWorker:
         self._sequence = 0
         self._closed = False
         self._tls_error = False
+        self.files = NativeWorkerFiles()
         env = dict(os.environ, PYTHONIOENCODING="utf-8", PYTHONDONTWRITEBYTECODE="1")
-        self.process = subprocess.Popen(
-            command or [sys.executable, "-u", "-m", "cfquant.qmt_native_worker"],
-            stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-            text=True, encoding="utf-8", errors="replace", bufsize=1, env=env,
-            cwd=str(Path(__file__).resolve().parents[1]),
-            creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0,
-        )
+        env.update(self.files.environment())
+        try:
+            self.process = subprocess.Popen(
+                command or [sys.executable, "-u", "-m", "cfquant.qmt_native_worker"],
+                stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                text=True, encoding="utf-8", errors="replace", bufsize=1, env=env,
+                cwd=str(Path(__file__).resolve().parents[1]),
+                creationflags=getattr(subprocess, "CREATE_NO_WINDOW", 0) if os.name == "nt" else 0,
+            )
+            try:
+                self.files.register(self.process.pid)
+            except Exception:
+                if self.process.poll() is None:
+                    self.process.kill()
+                self.process.wait(timeout=5)
+                for stream in (self.process.stdin, self.process.stdout, self.process.stderr):
+                    stream.close()
+                raise
+        except Exception:
+            self.files.close()
+            raise
         self._readers = [
             threading.Thread(target=self._read_responses, name="qmt-native-response", daemon=True),
             threading.Thread(target=self._read_errors, name="qmt-native-stderr", daemon=True),
@@ -154,7 +171,7 @@ class NativeWorker:
                 if not force and self.process.poll() is None:
                     self.process.stdin.write(json.dumps(dict(id=0, method="close")) + "\n")
                     self.process.stdin.flush()
-                    self.process.wait(timeout=1)
+                    self.process.wait(timeout=3)
             except (OSError, ValueError, subprocess.TimeoutExpired):
                 pass
             finally:
@@ -169,6 +186,79 @@ class NativeWorker:
                     thread.join(timeout=1)
                 self.process.stdout.close()
                 self.process.stderr.close()
+                self.files.close()
+
+
+class StrategyWorkerHost:
+    """Reuse one Frida host, but detach the QMT session after every inspection."""
+    def __init__(self, worker_factory=NativeWorker):
+        self.worker_factory = worker_factory
+        self.worker = None
+        self.lock = threading.RLock()
+        self.stopped = threading.Event()
+
+    def __call__(self, directory):
+        self.lock.acquire()
+        try:
+            if self.stopped.is_set():
+                raise QmtAutomationCancelled("QMT 策略检测已停止")
+            worker = self.worker
+            if worker is not None and (worker._closed or worker.process.poll() is not None):
+                worker.close(force=True)
+                self.worker = worker = None
+            if worker is None:
+                worker = self.worker_factory("strategy", directory, timeout=15,
+                                             should_cancel=self.stopped.is_set)
+                self.worker = worker
+            else:
+                sweep_worker_directories(worker.files.root)
+                info = worker.call("open", kind="strategy", directory=str(directory), timeout=15)
+                worker.pid, worker.main_hwnd = info.get("pid"), info.get("main_hwnd")
+            return _StrategyWorkerLease(self, worker)
+        except BaseException:
+            self._discard()
+            self.lock.release()
+            raise
+
+    def _discard(self):
+        if self.worker is not None:
+            worker, self.worker = self.worker, None
+            worker.close(force=True)
+
+    def close(self):
+        self.stopped.set()
+        with self.lock:
+            if self.worker is not None:
+                worker, self.worker = self.worker, None
+                worker.close()
+
+
+class _StrategyWorkerLease:
+    def __init__(self, host, worker):
+        self.host, self.worker = host, worker
+        self.pid, self.main_hwnd = worker.pid, worker.main_hwnd
+        self.closed = False
+
+    def __getattr__(self, name):
+        if name not in STRATEGY_METHODS:
+            raise AttributeError(name)
+        def call(*args, **kwargs):
+            if self.closed:
+                raise QmtAutomationCancelled("QMT 策略检测会话已关闭")
+            return self.worker.call(name, *args, **kwargs)
+        return call
+
+    def close(self):
+        if self.closed:
+            return
+        self.closed = True
+        try:
+            try:
+                self.worker.call("release")
+            except Exception:
+                self.host._discard()
+        finally:
+            self.host.lock.release()
 
 
 class IsolatedLoginBackend(NativeWorker):
@@ -232,6 +322,13 @@ def serve(factory=_open_backend):
                     opened = True
                     methods = LOGIN_METHODS if kwargs["kind"] == "login" else STRATEGY_METHODS
                     result = {key: getattr(backend, key, None) for key in ("pid", "main_hwnd")}
+                elif method == "release" and opened:
+                    try:
+                        if backend is not None:
+                            backend.close()
+                    finally:
+                        backend, opened, methods = None, False, frozenset()
+                    result = None
                 elif opened and backend is not None and method in methods:
                     result = getattr(backend, method)(*request.get("args", []), **request.get("kwargs", {}))
                 else:
@@ -244,9 +341,17 @@ def serve(factory=_open_backend):
             output.flush()
             request = None
     finally:
-        if backend is not None:
-            backend.close()
-        output.close()
+        try:
+            if backend is not None:
+                backend.close()
+        finally:
+            try:
+                # detach() releases a target session, not the host's DLL cache.
+                frida = sys.modules.get("frida")
+                if frida is not None:
+                    frida.shutdown()
+            finally:
+                output.close()
 
 
 if __name__ == "__main__":