cfquant 0.2.62__tar.gz → 0.2.63__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.62
+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.62 → 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.62 → 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.62 → cfquant-0.2.63}/cfquant/qmt_component_login.py

@@ -310,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
@@ -341,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.62 → 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__":

{cfquant-0.2.62 → cfquant-0.2.63}/cfquant/qmt_strategy_agent.js

@@ -4,7 +4,7 @@
 // agent while the project is being upgraded.
 (() => {
 // Resolve query, start and notice APIs independently of the login agent.
-const missing = {gui: [], query: [], start: [], notice: [], dismiss: []};
+const missing = {gui: [], query: [], start: [], whitelist: [], notice: [], dismiss: []};
 function native(group, moduleName, name, result, args) {
   const module = Process.findModuleByName(moduleName);
   const address = module && module.findExportByName(name);
@@ -30,7 +30,9 @@ const strategyManager = native('query', 'Formula.dll', '?instance@?$CSingletonT@
 const strategySave = native('query', 'Formula.dll', '?saveSettings@CStrategyTradeManager@TC@@QEAAXAEAVQDomElement@@AEAVQDomDocument@@@Z', 'void', ['pointer', 'pointer', 'pointer']);
 // isStrategyRun takes a request identifier; isFomrulaRun takes a formula name.
 const strategyRunning = native('query', 'Formula.dll', '?isFomrulaRun@CStrategyTradeManager@TC@@QEAA_NAEBVQString@@@Z', 'bool', ['pointer', 'pointer']);
-const strategyWhitelistReady = native('start', 'Formula.dll', '?isConnWhiteListReady@CStrategyTradeManager@TC@@QEBA_NXZ', 'bool', ['pointer']);
+// Older QMT builds expose runStrategy without a separate readiness query.
+// Use their native start path; never replace or change QMT whitelist checks.
+const strategyWhitelistReady = native('whitelist', 'Formula.dll', '?isConnWhiteListReady@CStrategyTradeManager@TC@@QEBA_NXZ', 'bool', ['pointer']);
 const strategyRun = native('start', 'Formula.dll', '?runStrategy@CStrategyTradeManager@TC@@QEAAXHAEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@std@@@Z', 'void', ['pointer', 'int', 'pointer']);
 const strategyDocCtor = native('query', 'Qt5Xml.dll', '??0QDomDocument@@QEAA@XZ', 'pointer', ['pointer']);
 const strategyDocDtor = native('query', 'Qt5Xml.dll', '??1QDomDocument@@QEAA@XZ', 'void', ['pointer']);
@@ -48,11 +50,12 @@ const closeNotice = native('dismiss', 'Dialog.dll', '?closeMessage@CGlobalMessag
 function capabilities() {
   const query = missing.gui.concat(missing.query);
   const start = query.concat(missing.start);
+  const whitelist = query.concat(missing.whitelist);
   const notice = query.concat(missing.notice);
   const dismiss = notice.concat(missing.dismiss);
-  return {can_query: !query.length, can_start: !start.length,
+  return {can_query: !query.length, can_start: !start.length, can_check_whitelist: !whitelist.length,
     can_read_notices: !notice.length, can_dismiss_notices: !dismiss.length,
-    missing_query: query, missing_start: start, missing_notice: notice, missing_dismiss: dismiss};
+    missing_query: query, missing_start: start, missing_whitelist: whitelist, missing_notice: notice, missing_dismiss: dismiss};
 }
 const typeNames = new Map();
 function hasType(object, name) {
@@ -228,7 +231,7 @@ rpc.exports.strategystart = (hwnd, expected) => onGui(hwnd, () => {
     throw new Error('Not an eligible managed strategy');
   }
   if (model.running) return {outcome: 'already_running', requested: false};
-  if (!snapshot.whitelist_ready) return {outcome: 'waiting_whitelist', requested: false};
+  if (snapshot.whitelist_ready === false) return {outcome: 'waiting_whitelist', requested: false};
   // Empty release-mode MSVC x64 std::string (SSO), matching the exported ABI.
   const reason = Memory.alloc(32);
   reason.writeByteArray(new Uint8Array(32));

{cfquant-0.2.62 → cfquant-0.2.63}/cfquant/qmt_strategy_deploy.py

@@ -848,6 +848,39 @@ class QmtStrategyManager:
             if changed:
                 self._save()
 
+    def prepare_for_start(self, directory):
+        """Finish this terminal's offline deployment before allowing launch."""
+        root = qmt_root(directory)
+        with self.lock:
+            if self.load_error:
+                raise ValueError(self.load_error)
+            jobs = [job for job in self.jobs.values()
+                    if os.path.normcase(str(qmt_root(job["root"]))) == os.path.normcase(str(root))]
+            if not jobs:
+                return
+            if self.process_checker(root):
+                raise RuntimeError("QMT 尚未完全退出，无法完成启动前策略部署")
+            try:
+                for job in jobs:
+                    if job.get("enabled") and self._prepare_generation_transition(job):
+                        self._control(job)
+                    try:
+                        self._advance(job)
+                    except Exception as error:
+                        count = int(job.get("deploy_retry_count") or 0) + 1
+                        job["deploy_retry_count"] = count
+                        job["deploy_retry_after"] = time.time() + min(10.0, 2.0 * count)
+                        self._state(job, "error", str(error))
+                        raise
+                    if (job.get("state") not in ("configured", "waiting_import", "disabled")
+                            or (job.get("enabled") and any(
+                                not role.get("model_prepared") or role.get("reimport_required")
+                                for role in job["roles"]))):
+                        raise RuntimeError("QMT 启动前策略部署尚未完成: " +
+                                           (job.get("message") or job.get("state", "")))
+            finally:
+                self._save()
+
     def _advance(self, job):
         root = qmt_root(job["root"])
         if self.process_checker(root):