cfquant 0.2.59__tar.gz → 0.2.60__tar.gz

{cfquant-0.2.59 → cfquant-0.2.60}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.59
+Version: 0.2.60
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8
@@ -15,7 +15,7 @@ Requires-Dist: pytz
 Requires-Dist: tabulate
 Requires-Dist: pandas-market-calendars
 Requires-Dist: importlib-resources>=5
-Requires-Dist: frida<18,>=17.0; sys_platform == "win32"
+Requires-Dist: frida==17.16.4; sys_platform == "win32"
 Requires-Dist: pywin32>=306; sys_platform == "win32"
 Provides-Extra: dev
 Requires-Dist: build>=1.0; extra == "dev"

{cfquant-0.2.59 → cfquant-0.2.60}/cfquant/_editable_install.py

@@ -10,9 +10,9 @@ import tempfile
 from pathlib import Path
 
 if __package__:
-    from .qmt_dependencies import report_startup_dependencies
+    from .qmt_dependencies import FRIDA_REQUIREMENT, FRIDA_VERSION, report_startup_dependencies
 else:
-    from qmt_dependencies import report_startup_dependencies
+    from qmt_dependencies import FRIDA_REQUIREMENT, FRIDA_VERSION, report_startup_dependencies
 
 
 PACKAGE_NAME = "cfquant"
@@ -517,6 +517,32 @@ def installed_package_version(python_exe=None):
     return completed.stdout.strip() if completed.returncode == 0 else ""
 
 
+def reconcile_startup_frida(project_root, python_exe):
+    """Repair version drift even when cfquant's own version did not change.
+
+    This launcher runs before Web/Frida loads. Failed optional repair must not
+    prevent manual QMT use; the native worker also checks before importing.
+    """
+    report = report_startup_dependencies(python_exe) or {}
+    if os.environ.get("CFQUANT_QMT_AUTOMATION", "1").lower() in ("0", "false", "off"):
+        return
+    if not report.get("supported") or not report.get("packages"):
+        return
+    if report["packages"].get("frida") == FRIDA_VERSION:
+        return
+    print("[INFO] Installing QMT compatibility dependency: %s" % FRIDA_REQUIREMENT)
+    command = [python_exe, "-m", "pip", "install", "--disable-pip-version-check", "--no-input",
+               "--timeout", "15", "--retries", "1"] + pip_index_args() + [FRIDA_REQUIREMENT]
+    try:
+        completed = subprocess.run(command, cwd=str(project_root), env=pip_environment(),
+                                   timeout=120, **_hidden_subprocess_kwargs())
+        if completed.returncode:
+            raise RuntimeError("pip exit code %s" % completed.returncode)
+    except (OSError, RuntimeError, subprocess.TimeoutExpired) as error:
+        print("[WARN] Frida compatibility repair failed: %s. Web can continue; use manual QMT login." % error)
+    report_startup_dependencies(python_exe)
+
+
 def ensure_cfquant_installed(project_root, python_exe=None):
     project_root = Path(project_root).resolve()
     if not (project_root / "pyproject.toml").is_file():
@@ -546,7 +572,7 @@ def ensure_cfquant_installed(project_root, python_exe=None):
     print("cfquant installed=%s project=%s" % (installed or "missing", expected))
     if installed == expected:
         print("Package versions match; skip installation.")
-        report_startup_dependencies(python_exe)
+        reconcile_startup_frida(project_root, python_exe)
         return 0
 
     command = editable_install_args(project_root, python_exe)
@@ -570,7 +596,7 @@ def ensure_cfquant_installed(project_root, python_exe=None):
         print("[ERROR] Installed cfquant version does not match the project after installation.", file=sys.stderr)
         return 1
     print("%s package is installed." % PACKAGE_NAME)
-    report_startup_dependencies(python_exe)
+    reconcile_startup_frida(project_root, python_exe)
     return 0
 
 

{cfquant-0.2.59 → cfquant-0.2.60}/cfquant/normal_bridge.py

@@ -194,7 +194,7 @@ class NormalQmtBridge(TxTradeBridge):
         if action == "cfquant.status":
             self._send_response(msg, self._status())
             return
-        if action == "cfquant.strategy.control":
+        if action in ("cfquant.strategy.control", "cfquant.account_subscription_status"):
             try:
                 self._send_response(msg, self._dispatch(action, msg.get("params") or {}, msg))
             except Exception as error:

{cfquant-0.2.59 → cfquant-0.2.60}/cfquant/protocol.py

@@ -154,7 +154,8 @@ def is_readonly_request(action):
     # Only known query families. Downloads, subscriptions and all writes retain
     # their existing execution semantics, including on an ambiguous timeout.
     return (str(action).startswith(("xtdata.get_", "xttrader.query_"))
-            or action in ("cfquant.ping", "cfquant.status", "cfquant.query_info"))
+            or action in ("cfquant.ping", "cfquant.status", "cfquant.query_info",
+                          "cfquant.account_subscription_status"))
 
 
 def request_expired(msg, now=None):

cfquant-0.2.60/cfquant/qmt_binding_defaults.py

@@ -0,0 +1,54 @@
+"""One-time migration of QMT automation preferences, using saved version evidence."""
+import copy
+import re
+
+
+AUTOMATION_DEFAULTS_VERSION = "0.2.59"
+MIGRATION_KEY = "qmt_automation_defaults_migration"
+
+
+def is_pre_automation_defaults_version(value):
+    """Schema numbers, missing values and unrecognized versions are not evidence."""
+    match = re.fullmatch(r"v?(\d+)\.(\d+)\.(\d+)(?:(a|b|rc)\d+)?(?:\.post\d+)?(?:\+[-\w.]+)?", str(value or "").strip())
+    if not match:
+        return False
+    version = tuple(int(match.group(i)) for i in (1, 2, 3))
+    return version < (0, 2, 59) or (version == (0, 2, 59) and bool(match.group(4)))
+
+
+def migrate_qmt_automation_defaults(raw):
+    """Return a copy only when a known old configuration needs migration.
+
+    The running/installed version and QMT's version do not date user preferences.
+    They must never be used as substitutes for the saved configuration version.
+    """
+    if not isinstance(raw, dict) or raw.get(MIGRATION_KEY):
+        return raw, 0
+    source_version = raw.get("saved_core_version", raw.get("core_version"))
+    if not is_pre_automation_defaults_version(source_version):
+        return raw, 0
+    result = copy.deepcopy(raw)
+    changed = 0
+    for collection in ("account_configs", "account_pairs"):
+        rows = result.get(collection) or {}
+        rows = rows.values() if isinstance(rows, dict) else rows if isinstance(rows, list) else []
+        for row in rows:
+            if not isinstance(row, dict) or not row.get("account_id"):
+                continue
+            login = row.get("qmt_auto_login")
+            login = dict(login) if isinstance(login, dict) else {}
+            login.update(enabled=True, auto_update=True)
+            # Preserve custom schedules and explicit empty schedules. Only absent
+            # schedules receive the same default as a new binding.
+            if not any(key in login for key in ("restart_times", "restartTimes", "restart_time", "restartTime")):
+                login["restart_times"] = ["09:00"]
+            row["qmt_auto_login"] = login
+            if collection == "account_configs":
+                strategy = row.get("qmt_strategy")
+                strategy = dict(strategy) if isinstance(strategy, dict) else {}
+                strategy.update(enabled=True, autorun=True)
+                row["qmt_strategy"] = strategy
+                changed += 1
+    result[MIGRATION_KEY] = {"version": AUTOMATION_DEFAULTS_VERSION, "source_version": str(source_version),
+                             "bindings": changed}
+    return result, changed

{cfquant-0.2.59 → cfquant-0.2.60}/cfquant/qmt_component_login.py

@@ -11,6 +11,8 @@ from pathlib import Path
 import sys
 import time
 
+from .qmt_native_worker import IsolatedLoginBackend, QmtAutomationCancelled, verify_environment_isolated
+
 
 class QmtNotReady(RuntimeError):
     pass
@@ -22,6 +24,11 @@ class QmtProcessExited(RuntimeError):
 
 def verify_environment(directory):
     """Validate dependencies and native ABI before stopping a running terminal."""
+    verify_environment_isolated(directory)
+
+
+def _verify_environment_native(directory):
+    """Only invoked inside the native worker or the standalone login CLI."""
     try:
         from .qmt_dependencies import LOGIN_MODULES, import_login_module
     except ImportError:
@@ -163,7 +170,7 @@ 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(directory)
+        _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):
@@ -367,8 +374,11 @@ def login_running_qmt(directory, login_account="", password_provider=lambda: "",
         if should_cancel():
             return {"outcome": "cancelled", "login_succeeded": False, "attempts": []}
         try:
-            backend = QtLoginBackend(Path(directory), timeout, expected_pid=expected_pid)
+            backend = IsolatedLoginBackend(Path(directory), timeout, expected_pid=expected_pid,
+                                           should_cancel=should_cancel)
             break
+        except QmtAutomationCancelled:
+            return {"outcome": "cancelled", "login_succeeded": False, "attempts": []}
         except QmtProcessExited:
             return {"outcome": "process_exited", "login_succeeded": False, "attempts": []}
         except QmtNotReady:
@@ -380,6 +390,8 @@ def login_running_qmt(directory, login_account="", password_provider=lambda: "",
         backend.should_cancel = should_cancel
         return auto_login(backend, password_provider, retry_not_ready=True, login_account=login_account,
                           should_cancel=should_cancel, on_wait=on_wait)
+    except QmtAutomationCancelled:
+        return {"outcome": "cancelled", "login_succeeded": False, "attempts": []}
     except QmtProcessExited:
         return {"outcome": "process_exited", "login_succeeded": False, "attempts": []}
     finally:

{cfquant-0.2.59 → cfquant-0.2.60}/cfquant/qmt_dependencies.py

@@ -1,6 +1,7 @@
 """Read-only checks and repair instructions for optional QMT login components."""
 import copy
 import importlib
+import importlib.metadata
 import json
 import os
 import subprocess
@@ -10,6 +11,10 @@ import time
 
 
 LOGIN_MODULES = ("frida", "win32api", "win32crypt", "win32event", "win32gui", "win32process")
+# Verified QMT baseline. 17.25 introduced a Windows mapper that can abort the
+# host on older ntdll builds; do not widen this without Windows/QMT validation.
+FRIDA_VERSION = "17.16.4"
+FRIDA_REQUIREMENT = "frida==" + FRIDA_VERSION
 _LOCK = threading.Lock()
 _CACHE = {}
 _PROBE_CODE = r'''
@@ -17,6 +22,8 @@ import importlib, importlib.metadata, json, os, pathlib, sys
 checks = []
 for name in MODULES:
     try:
+        if name == 'frida' and importlib.metadata.version('frida') != FRIDA_VERSION:
+            raise RuntimeError('Unsupported Frida version; install frida==' + FRIDA_VERSION)
         module = importlib.import_module(name)
         checks.append(dict(name=name, ok=True, path=getattr(module, '__file__', '')))
     except Exception as error:
@@ -46,6 +53,16 @@ def _ps_quote(value):
 
 
 def _finish_report(report):
+    if report.get("supported"):
+        version = (report.get("packages") or {}).get("frida")
+        if version and version != FRIDA_VERSION:
+            checks = report.setdefault("checks", [])
+            check = next((item for item in checks if item["name"] == "frida"), None)
+            if check is None:
+                check = {"name": "frida"}
+                checks.append(check)
+            check.update(ok=False, error="Frida %s 未通过本项目兼容性验证，请安装 %s" % (version, FRIDA_REQUIREMENT))
+        report["frida_requirement"] = FRIDA_REQUIREMENT
     report["checked_at"] = time.time()
     report["ok"] = bool(report.get("supported") and not report.get("error")
                         and all(item["ok"] for item in report.get("checks", [])))
@@ -73,8 +90,10 @@ def _finish_report(report):
                 if environment == "python":
                     commands.append(python + " -m pywin32_postinstall -install")
         if any(item["name"] == "frida" for item in failed):
-            commands.append(python + " -m pip install --no-cache-dir --upgrade --force-reinstall 'frida>=17.0,<18'")
-        commands.append(python + " -c " + _ps_quote("import " + ", ".join(LOGIN_MODULES) + "; print('QMT login components OK')"))
+            commands.append(python + " -m pip install --no-cache-dir --force-reinstall '" + FRIDA_REQUIREMENT + "'")
+        commands.append(python + " -c " + _ps_quote(
+            "from cfquant.qmt_dependencies import report_startup_dependencies; "
+            "r=report_startup_dependencies(); raise SystemExit(0 if r['ok'] else 1)"))
     report["repair_commands"] = commands
     if environment == "conda":
         report["repair_note"] = (
@@ -111,7 +130,7 @@ def check_login_dependencies(python_exe=None, refresh=False, timeout=15):
             if os.name == "nt":
                 run_kwargs["creationflags"] = getattr(subprocess, "CREATE_NO_WINDOW", 0)
             completed = subprocess.run(
-                [executable, "-c", "MODULES = %r\n" % (LOGIN_MODULES,) + _PROBE_CODE],
+                [executable, "-c", "MODULES = %r\nFRIDA_VERSION = %r\n" % (LOGIN_MODULES, FRIDA_VERSION) + _PROBE_CODE],
                 stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8",
                 errors="replace", timeout=timeout,
                 **run_kwargs,
@@ -130,8 +149,21 @@ class QmtDependencyError(RuntimeError):
     pass
 
 
+def require_compatible_frida():
+    try:
+        version = importlib.metadata.version("frida")
+    except importlib.metadata.PackageNotFoundError:
+        version = "未安装"
+    if version != FRIDA_VERSION:
+        raise QmtDependencyError(
+            "Frida %s 未通过本项目兼容性验证，已跳过 QMT 自动操作。"
+            "请在当前 Python 环境安装 %s；手动登录及行情交易接口仍可使用。" % (version, FRIDA_REQUIREMENT))
+
+
 def import_login_module(name):
     """Keep in-process import errors actionable, including stale loaded DLLs."""
+    if name == "frida":
+        require_compatible_frida()
     try:
         return importlib.import_module(name)
     except (ImportError, OSError) as error:

cfquant-0.2.60/cfquant/qmt_native_worker.py

@@ -0,0 +1,253 @@
+"""Isolate QMT/Frida native code from the Web process using private stdio RPC.
+
+Credentials only travel over the child's stdin, never argv, files or logs.
+Requests are not replayed after a crash or timeout: a native action may have run.
+"""
+import json
+import os
+from pathlib import Path
+import queue
+import subprocess
+import sys
+import threading
+import time
+
+
+LOGIN_METHODS = frozenset(("already_logged_in", "state", "select_account", "submit",
+                           "fill", "wait_outcome", "acknowledge_failure"))
+STRATEGY_METHODS = frozenset(("snapshot", "start_strategy", "notices", "dismiss_notice"))
+MAX_MESSAGE = 4 * 1024 * 1024
+
+
+class QmtAutomationError(RuntimeError):
+    """A failed native worker; safe to display without native exception contents."""
+
+
+class QmtAutomationCancelled(QmtAutomationError):
+    pass
+
+
+class NativeWorker:
+    def __init__(self, kind, directory, *, timeout=40, expected_pid=None,
+                 should_cancel=lambda: False, command=None):
+        if os.environ.get("CFQUANT_QMT_AUTOMATION", "1").lower() in ("0", "false", "off"):
+            raise QmtAutomationError("QMT 原生自动化已关闭，请手动登录并启动策略；Web 服务及行情交易接口仍可使用。")
+        self.should_cancel = should_cancel
+        self.call_timeout = max(15.0, float(timeout) + 10)
+        self.methods = LOGIN_METHODS if kind == "login" else STRATEGY_METHODS
+        self._lock = threading.RLock()
+        self._responses = queue.Queue()
+        self._sequence = 0
+        self._closed = False
+        self._tls_error = False
+        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,
+        )
+        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),
+        ]
+        for thread in self._readers:
+            thread.start()
+        try:
+            info = self.call("open", kind=kind, directory=str(directory), timeout=timeout,
+                             expected_pid=expected_pid)
+            self.pid = info.get("pid")
+            self.main_hwnd = info.get("main_hwnd")
+        except BaseException:
+            self.close(force=True)
+            raise
+
+    def _read_responses(self):
+        try:
+            while True:
+                line = self.process.stdout.readline(MAX_MESSAGE + 1)
+                if not line or len(line) > MAX_MESSAGE:
+                    break
+                self._responses.put(json.loads(line))
+        except (ValueError, OSError):
+            pass
+        finally:
+            self._responses.put(None)
+
+    def _read_errors(self):
+        try:
+            while True:
+                chunk = self.process.stderr.readline(4096)
+                if not chunk:
+                    break
+                if "Unable to locate the ntdll loader TLS routines" in chunk:
+                    self._tls_error = True
+                # Native output can contain input values; never forward it.
+        except (ValueError, OSError):
+            pass
+
+    def _failure(self, reason):
+        from .qmt_dependencies import FRIDA_REQUIREMENT
+        detail = "Frida 与当前 Windows 不兼容" if self._tls_error else reason
+        return QmtAutomationError(
+            "QMT 自动化子进程%s，已停止本次自动操作，Web 服务继续运行。"
+            "请检查自动登录组件并安装 %s，或手动登录、启动 QMT 策略。" % (detail, FRIDA_REQUIREMENT))
+
+    def call(self, method, *args, **kwargs):
+        with self._lock:
+            if self._closed:
+                raise self._failure("已关闭")
+            self._sequence += 1
+            request_id = self._sequence
+            try:
+                if self.should_cancel():
+                    raise QmtAutomationCancelled("QMT 自动操作已取消")
+                message = json.dumps(dict(id=request_id, method=method, args=args, kwargs=kwargs), ensure_ascii=True)
+                if len(message) > MAX_MESSAGE:
+                    raise self._failure("请求过大")
+                self.process.stdin.write(message + "\n")
+                self.process.stdin.flush()
+                deadline = time.monotonic() + self.call_timeout
+                while True:
+                    if self.should_cancel():
+                        raise QmtAutomationCancelled("QMT 自动操作已取消")
+                    remaining = deadline - time.monotonic()
+                    if remaining <= 0:
+                        raise self._failure("响应超时")
+                    try:
+                        reply = self._responses.get(timeout=min(.1, remaining))
+                        break
+                    except queue.Empty:
+                        continue
+                if not isinstance(reply, dict) or reply.get("id") != request_id:
+                    raise self._failure("异常退出或通信中断")
+            except (BrokenPipeError, OSError) as error:
+                self.close(force=True)
+                raise self._failure("通信中断") from error
+            except BaseException:
+                self.close(force=True)
+                raise
+            if not reply.get("ok"):
+                self._raise_remote(reply)
+            return reply.get("result")
+
+    @staticmethod
+    def _raise_remote(reply):
+        from .qmt_component_login import QmtNotReady, QmtProcessExited
+        from .qmt_dependencies import QmtDependencyError
+        from .qmt_strategy_recovery import UnsupportedQmt
+        errors = {cls.__name__: cls for cls in (QmtNotReady, QmtProcessExited, QmtDependencyError, UnsupportedQmt)}
+        raise errors.get(reply.get("error_type"), RuntimeError)(reply.get("error") or "QMT native operation failed")
+
+    def __getattr__(self, name):
+        if name not in self.methods:
+            raise AttributeError(name)
+        return lambda *args, **kwargs: self.call(name, *args, **kwargs)
+
+    def close(self, force=False):
+        with self._lock:
+            if self._closed:
+                return
+            self._closed = True
+            try:
+                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)
+            except (OSError, ValueError, subprocess.TimeoutExpired):
+                pass
+            finally:
+                if self.process.poll() is None:
+                    self.process.kill()
+                self.process.wait(timeout=5)
+                try:
+                    self.process.stdin.close()
+                except OSError:
+                    pass  # A crash may leave buffered input with no reader.
+                for thread in self._readers:
+                    thread.join(timeout=1)
+                self.process.stdout.close()
+                self.process.stderr.close()
+
+
+class IsolatedLoginBackend(NativeWorker):
+    def __init__(self, directory, timeout=40, expected_pid=None, *, should_cancel=lambda: False):
+        super().__init__("login", directory, timeout=timeout, expected_pid=expected_pid, should_cancel=should_cancel)
+
+
+class IsolatedStrategyBackend(NativeWorker):
+    def __init__(self, directory):
+        super().__init__("strategy", directory, timeout=15)
+
+
+def verify_environment_isolated(directory):
+    worker = NativeWorker("verify", directory, timeout=5)
+    worker.close()
+
+
+def _open_backend(kind, directory, timeout=40, expected_pid=None):
+    from .qmt_component_login import QtLoginBackend, _verify_environment_native
+    if kind == "verify":
+        _verify_environment_native(directory)
+        return None
+    if kind == "login":
+        return QtLoginBackend(Path(directory), timeout, expected_pid=expected_pid)
+    if kind == "strategy":
+        from .qmt_strategy_recovery import QtStrategyBackend
+        return QtStrategyBackend(directory)
+    raise ValueError("Unknown QMT worker kind")
+
+
+def serve(factory=_open_backend):
+    # Reserve stdout for protocol, including when a native DLL prints to fd 1.
+    output = os.fdopen(os.dup(sys.stdout.fileno()), "w", encoding="utf-8", buffering=1)
+    os.dup2(sys.stderr.fileno(), sys.stdout.fileno())
+    sys.stdout = sys.stderr
+    requests = queue.Queue(maxsize=2)
+    def receive():
+        try:
+            while True:
+                line = sys.stdin.readline(MAX_MESSAGE + 1)
+                if not line or len(line) > MAX_MESSAGE:
+                    break
+                requests.put(json.loads(line))
+        finally:
+            # Also stop a hung native call if the Web parent exits unexpectedly.
+            os._exit(0)
+    threading.Thread(target=receive, name="qmt-native-input", daemon=True).start()
+    backend = None
+    opened = False
+    methods = frozenset()
+    try:
+        while True:
+            request = requests.get()
+            method = request.get("method")
+            if method == "close":
+                break
+            try:
+                if method == "open" and not opened:
+                    kwargs = request["kwargs"]
+                    backend = factory(**kwargs)
+                    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 opened and backend is not None and method in methods:
+                    result = getattr(backend, method)(*request.get("args", []), **request.get("kwargs", {}))
+                else:
+                    raise ValueError("Unsupported QMT worker request")
+                reply = dict(id=request["id"], ok=True, result=result)
+            except Exception as error:
+                reply = dict(id=request["id"], ok=False, error_type=type(error).__name__,
+                             error="QMT credential entry failed" if method == "fill" else str(error))
+            output.write(json.dumps(reply, ensure_ascii=True) + "\n")
+            output.flush()
+            request = None
+    finally:
+        if backend is not None:
+            backend.close()
+        output.close()
+
+
+if __name__ == "__main__":
+    serve()

{cfquant-0.2.59 → cfquant-0.2.60}/cfquant/qmt_strategy_recovery.py

@@ -16,6 +16,8 @@ import time
 import uuid
 
 from .qmt_component_login import QtLoginBackend, QmtNotReady
+from .qmt_native_worker import IsolatedStrategyBackend, QmtAutomationError
+from .qmt_dependencies import QmtDependencyError
 from .qmt_strategy_deploy import (
     _role_stock, _strategy_slot_name, account_qmt_roots,
     _write_json, _digest, PipeStrategyController, normalize_strategy_mode, normalize_strategy_settings, qmt_root,
@@ -166,7 +168,7 @@ def match_models(snapshot, expected):
 
 
 class QmtStrategyRecovery:
-    def __init__(self, accounts_provider, *, backend_factory=QtStrategyBackend,
+    def __init__(self, accounts_provider, *, backend_factory=IsolatedStrategyBackend,
                  job_is_current=lambda job: True, clock=time.time, interval=20.0,
                  notice_probe=visible_notice_windows, event_sink=None, bridge_verifier=confirm_recovery_bridge):
         self.accounts_provider = accounts_provider
@@ -235,10 +237,12 @@ class QmtStrategyRecovery:
             return job["recovery"]
         previous = job.get("recovery") or {}
         if (not inspect_only and now < previous.get("next_check_at", 0)
-                and not self.notice_probe(previous.get("pid"), previous.get("main_hwnd"))):
+                and (previous.get("native_failure")
+                     or not self.notice_probe(previous.get("pid"), previous.get("main_hwnd")))):
             return previous
         status = dict(previous, last_checked_at=now, next_check_at=now + self.interval)
         status.pop("error", None)
+        status.pop("native_failure", None)
         backend = None
         try:
             backend = self.backend_factory(job["root"])
@@ -303,6 +307,7 @@ class QmtStrategyRecovery:
         except Exception as error:
             status.update(state="unsupported" if isinstance(error, UnsupportedQmt) else "unavailable",
                           error=str(error), next_check_at=now + max(self.interval, 60))
+            status["native_failure"] = isinstance(error, (QmtAutomationError, QmtDependencyError))
             if status.get("incident") and status.get("last_logged_error") != str(error):
                 try:
                     self._event(job, status, "illegal_ip_processing_failed", error=str(error))

{cfquant-0.2.59 → cfquant-0.2.60}/cfquant/rpc_timing.py

@@ -38,6 +38,8 @@ class RpcTiming(object):
         if self.sent_at is not None:
             self.output["rpc"]["response_wait_ms"] = round((self.received_at - self.sent_at) * 1000, 3)
         meta = message.get("meta") or {}
+        if "web_queue_ms" in meta:
+            self.output["web"] = {"queue_ms": meta["web_queue_ms"], "route": meta.get("route")}
         qmt = (meta.get("timing") or {}).get("qmt")
         self.output["qmt"] = dict(qmt) if isinstance(qmt, dict) else {
             "available": False, "reason": "bridge_timing_unavailable",