cfquant 0.2.54__tar.gz → 0.2.56__tar.gz

{cfquant-0.2.54 → cfquant-0.2.56}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.54
+Version: 0.2.56
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8
@@ -343,6 +343,8 @@ trader.disconnect()
 
 `XtQuantTrader`、`StockAccount`、常用行情查询和交易方法保持接近 `xtquant` 的调用方式，原有回调类通常可以继续使用。仍有部分 QMT 专有接口、字段和返回结构存在兼容边界，使用前请查看 [xtquant 原版接口适配清单](docs/xtquant原版接口适配清单.md) 和 [QMT 函数封装能力清单](docs/QMT函数封装能力清单.md)。
 
+账号订阅成功后，SDK 会在后台约每两秒重新确认订阅。用户程序保持运行时，QMT、cfquant Web 或通信服务重启后，待桥接策略恢复授权、通道可用，SDK 会自动恢复该账号的新回调；默认 Web 路由和直接 Pipe/LTtx 连接均适用。主动 `unsubscribe(account)` 后不会再恢复该账号，`stop()` / `disconnect()` 会停止后台恢复。此机制只恢复账号订阅，不补发停机期间的回调，也不重试委托或撤单。升级 SDK 后需先重启一次用户程序加载新代码，此后无需随 QMT 重启用户程序。
+
 推荐迁移顺序：**行情查询 → 资金/持仓 → 回调 → 模拟委托 → 模拟撤单 → 正式策略**。每一步都先在 Web 控制台接口测试和日志中确认，再进入下一步。
 
 ## Web 控制台

{cfquant-0.2.54 → cfquant-0.2.56}/README.md

@@ -317,9 +317,11 @@ trader.disconnect()
 
 ### 回调和接口差异
 
-`XtQuantTrader`、`StockAccount`、常用行情查询和交易方法保持接近 `xtquant` 的调用方式，原有回调类通常可以继续使用。仍有部分 QMT 专有接口、字段和返回结构存在兼容边界，使用前请查看 [xtquant 原版接口适配清单](docs/xtquant原版接口适配清单.md) 和 [QMT 函数封装能力清单](docs/QMT函数封装能力清单.md)。
-
-推荐迁移顺序：**行情查询 → 资金/持仓 → 回调 → 模拟委托 → 模拟撤单 → 正式策略**。每一步都先在 Web 控制台接口测试和日志中确认，再进入下一步。
+`XtQuantTrader`、`StockAccount`、常用行情查询和交易方法保持接近 `xtquant` 的调用方式，原有回调类通常可以继续使用。仍有部分 QMT 专有接口、字段和返回结构存在兼容边界，使用前请查看 [xtquant 原版接口适配清单](docs/xtquant原版接口适配清单.md) 和 [QMT 函数封装能力清单](docs/QMT函数封装能力清单.md)。
+
+账号订阅成功后，SDK 会在后台约每两秒重新确认订阅。用户程序保持运行时，QMT、cfquant Web 或通信服务重启后，待桥接策略恢复授权、通道可用，SDK 会自动恢复该账号的新回调；默认 Web 路由和直接 Pipe/LTtx 连接均适用。主动 `unsubscribe(account)` 后不会再恢复该账号，`stop()` / `disconnect()` 会停止后台恢复。此机制只恢复账号订阅，不补发停机期间的回调，也不重试委托或撤单。升级 SDK 后需先重启一次用户程序加载新代码，此后无需随 QMT 重启用户程序。
+
+推荐迁移顺序：**行情查询 → 资金/持仓 → 回调 → 模拟委托 → 模拟撤单 → 正式策略**。每一步都先在 Web 控制台接口测试和日志中确认，再进入下一步。
 
 ## Web 控制台
 

{cfquant-0.2.54 → cfquant-0.2.56}/cfquant/_editable_install.py

@@ -9,6 +9,11 @@ import sys
 import tempfile
 from pathlib import Path
 
+if __package__:
+    from .qmt_dependencies import report_startup_dependencies
+else:
+    from qmt_dependencies import report_startup_dependencies
+
 
 PACKAGE_NAME = "cfquant"
 
@@ -503,6 +508,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)
         return 0
 
     command = editable_install_args(project_root, python_exe)
@@ -526,6 +532,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)
     return 0
 
 

{cfquant-0.2.54 → cfquant-0.2.56}/cfquant/batch_orders.py

@@ -197,6 +197,8 @@ def batch_cancel_result_rows(cancels, seqs=None):
 def batch_result(account, batch_id, asynchronous, results, operation="order"):
     counts = {name: sum(row["status"] == name for row in results)
               for name in ("submitted", "failed", "unknown", "skipped")}
+    counts["rejected"] = sum(row.get("dispatched") is False for row in results)
+    counts["retryable"] = sum(row.get("safe_to_retry") is True for row in results)
     return dict(counts, batch_id=batch_id, account=account, asynchronous=asynchronous,
                 operation=operation, execution="qmt", total=len(results), attempted=len(results) - counts["skipped"],
                 ok=counts["submitted"] == len(results), results=results)
@@ -207,6 +209,19 @@ def batch_unknown(rows, error):
         row.update(status="unknown", ok=None, error=str(error) or type(error).__name__)
 
 
+def batch_rejected(rows, error):
+    """Mark a rejection known to happen before QMT dispatch."""
+    details = getattr(error, "error_details", None)
+    details = details if isinstance(details, dict) else {}
+    message = str(error) or type(error).__name__
+    for row in rows:
+        row.update(status="failed", ok=False, error=message, dispatched=False,
+                   safe_to_retry=details.get("safe_to_retry") is True,
+                   retry_when=details.get("retry_when", ""),
+                   error_code=details.get("code", ""),
+                   error_stage=details.get("stage", "before_dispatch"))
+
+
 def validate_batch_response(result, params, asynchronous):
     expected = params["orders"]
     if (not isinstance(result, dict) or result.get("execution") != "qmt"

{cfquant-0.2.54 → cfquant-0.2.56}/cfquant/cftrader.py

@@ -1,7 +1,7 @@
 """Order-only extensions sharing an existing XtQuantTrader session and callbacks."""
 
 from .batch_orders import (
-    batch_cancel_result_rows, batch_result, batch_result_rows, batch_unknown,
+    batch_cancel_result_rows, batch_rejected, batch_result, batch_result_rows, batch_unknown,
     prepare_batch_cancels, prepare_batch_orders, validate_batch_cancel_response, validate_batch_response,
 )
 from .protocol import new_id
@@ -86,9 +86,18 @@ class CfQuantTrader:
             result = validate_batch_response(response, params, asynchronous)
         except Exception as error:
             results = batch_result_rows(rows, seqs)
-            batch_unknown(results, "Batch response unavailable; QMT may still execute the batch: %s" % error)
+            if getattr(error, "dispatched", None) is False:
+                batch_rejected(results, error)
+            else:
+                batch_unknown(results, "Batch response unavailable; QMT may still execute the batch: %s" % error)
             result = batch_result(account, batch_id, asynchronous, results)
             result["request_error"] = str(error) or type(error).__name__
+            details = getattr(error, "error_details", None)
+            if isinstance(details, dict):
+                result.update(error_code=details.get("code", ""), error_stage=details.get("stage", ""),
+                              dispatched=details.get("dispatched"), safe_to_retry=details.get("safe_to_retry") is True,
+                              retry_when=details.get("retry_when", ""),
+                              runtime_instance_id=details.get("runtime_instance_id", ""))
         if asynchronous:
             for row in result["results"]:
                 if row["status"] in ("failed", "skipped"):
@@ -113,7 +122,16 @@ class CfQuantTrader:
             return validate_batch_cancel_response(response, params, asynchronous)
         except Exception as error:
             results = batch_cancel_result_rows(rows, seqs)
-            batch_unknown(results, "Batch cancel response unavailable; QMT may still execute the batch: %s" % error)
+            if getattr(error, "dispatched", None) is False:
+                batch_rejected(results, error)
+            else:
+                batch_unknown(results, "Batch cancel response unavailable; QMT may still execute the batch: %s" % error)
             result = batch_result(account, batch_id, asynchronous, results, operation="cancel")
             result["request_error"] = str(error) or type(error).__name__
+            details = getattr(error, "error_details", None)
+            if isinstance(details, dict):
+                result.update(error_code=details.get("code", ""), error_stage=details.get("stage", ""),
+                              dispatched=details.get("dispatched"), safe_to_retry=details.get("safe_to_retry") is True,
+                              retry_when=details.get("retry_when", ""),
+                              runtime_instance_id=details.get("runtime_instance_id", ""))
             return result

{cfquant-0.2.54 → cfquant-0.2.56}/cfquant/client.py

@@ -12,8 +12,17 @@ from .protocol import decode_value, dumps_message, loads_message, new_id, pack_r
 from .rpc_timing import RpcTiming
 
 
-class CfquantError(RuntimeError):
-    pass
+class CfquantError(RuntimeError):
+    """RPC failure retaining the server's structured rejection details."""
+
+    def __init__(self, message="", details=None):
+        super(CfquantError, self).__init__(message)
+        self.error_details = dict(details) if isinstance(details, dict) else {}
+        self.code = self.error_details.get("code", "")
+        self.stage = self.error_details.get("stage", "")
+        self.dispatched = self.error_details.get("dispatched")
+        self.safe_to_retry = self.error_details.get("safe_to_retry", False) is True
+        self.retry_when = self.error_details.get("retry_when", "")
 
 
 class CfquantTimeout(TimeoutError):
@@ -209,6 +218,7 @@ class LTtxRpcClient(object):
                 with self._pending_lock:
                     self._pending[request_id] = q
                 self._push("request", raw, request_channel or self.request_channel)
+                timing.sent()
             try:
                 msg = _wait_response(q, effective_timeout)
             except queue.Empty:
@@ -216,7 +226,7 @@ class LTtxRpcClient(object):
             timing.received(msg)
             if not msg.get("ok"):
                 err = msg.get("error") or {}
-                raise CfquantError(err.get("message") or str(err))
+                raise CfquantError(err.get("message") or str(err), details=err)
             return timing.decode(msg.get("result"), decode_value)
         except (KeyboardInterrupt, SystemExit):
             self.close()

{cfquant-0.2.54 → cfquant-0.2.56}/cfquant/normal_bridge.py

@@ -837,6 +837,7 @@ class NormalQmtBridge(TxTradeBridge):
             if not active:
                 return
             msg = active[0][0]
+            dispatch_started = time.perf_counter()
             result = self._dispatch(msg.get("action"), msg.get("params") or {}, msg)
             with self.coalesce_lock:
                 entry = self.coalesced_requests.pop(coalesce_key, None)
@@ -847,6 +848,15 @@ class NormalQmtBridge(TxTradeBridge):
             encoded_result = encode_response_result(result)
             while response_waiters:
                 waiter_msg, _ = response_waiters[0]
+                if msg.get("_response_meta") and str(msg.get("action", "")).startswith("xttrader.query_stock_"):
+                    # Coalesced readers share execution, but each keeps its own ID
+                    # and queue delay (including readers arriving during execution).
+                    timing = dict(msg["_response_meta"]["timing"]["qmt"])
+                    received = waiter_msg.get("_received_monotonic")
+                    if received is not None:
+                        timing["queue_ms"] = round(max(0.0, dispatch_started - received) * 1000, 3)
+                    timing["coalesced_request_id"] = msg.get("id")
+                    waiter_msg["_response_meta"] = {"timing": {"qmt": timing}}
                 self._send_response(waiter_msg, result, encoded_result=encoded_result)
                 response_waiters.pop(0)
             self._log(
@@ -864,6 +874,13 @@ class NormalQmtBridge(TxTradeBridge):
                 % (source, msg.get("action"), msg.get("id"), len(waiters), e)
             )
             for waiter_msg, _ in waiters:
+                if msg.get("_response_meta") and str(msg.get("action", "")).startswith("xttrader.query_stock_"):
+                    timing = dict(msg["_response_meta"]["timing"]["qmt"])
+                    received = waiter_msg.get("_received_monotonic")
+                    if received is not None:
+                        timing["queue_ms"] = round(max(0.0, dispatch_started - received) * 1000, 3)
+                    timing["coalesced_request_id"] = msg.get("id")
+                    waiter_msg["_response_meta"] = {"timing": {"qmt": timing}}
                 self._send_error(waiter_msg, e)
 
     def _on_whole_quote(self, data):
@@ -908,6 +925,13 @@ class NormalQmtBridge(TxTradeBridge):
         client_id = msg.get("client_id") or msg.get("reply_channel")
         if not client_id:
             return
+        if (not msg.get("_response_meta") and str(msg.get("action", "")).startswith("xttrader.query_stock_")
+                and str(error) == "read-only request expired before QMT execution"):
+            received = msg.get("_received_monotonic")
+            msg["_response_meta"] = {"timing": {"qmt": {
+                "available": True, "executed": False, "native_ms": 0.0, "execute_ms": 0.0,
+                "queue_ms": round((time.perf_counter() - received) * 1000, 3) if received is not None else None,
+            }}}
         self._log(
             "normal bridge send_error action=%s id=%s client_id=%s error=%s"
             % (msg.get("action"), msg.get("id"), client_id, error)

{cfquant-0.2.54 → cfquant-0.2.56}/cfquant/pipe_client.py

@@ -48,18 +48,24 @@ class PipeRpcClient(object):
             if self._started:
                 self._started = False
                 self._close_conns_locked()
-            self._rx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
-            self._rx_conn.write_frame(dumps_pipe_message({
-                "type": "hello",
-                "role": "api_rx",
-                "client_id": self.client_id,
-            }))
-            self._tx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
-            self._tx_conn.write_frame(dumps_pipe_message({
-                "type": "hello",
-                "role": "api_tx",
-                "client_id": self.client_id,
-            }))
+            try:
+                self._rx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
+                self._rx_conn.write_frame(dumps_pipe_message({
+                    "type": "hello",
+                    "role": "api_rx",
+                    "client_id": self.client_id,
+                }))
+                self._tx_conn = connect_pipe(self.pipe_name, timeout_ms=self.connect_timeout_ms)
+                self._tx_conn.write_frame(dumps_pipe_message({
+                    "type": "hello",
+                    "role": "api_tx",
+                    "client_id": self.client_id,
+                }))
+            except BaseException:
+                # A retry must not orphan the receive pipe when opening or
+                # registering the send pipe failed halfway through startup.
+                self.close()
+                raise
             self._started = True
             self._closed = False
             generation = self._event_dispatcher.start()
@@ -95,6 +101,7 @@ class PipeRpcClient(object):
                     self._pending[request_id] = q
                 try:
                     self._send_request(raw, request_channel or self.request_channel)
+                    timing.sent()
                 except Exception:
                     self.close()
                     raise
@@ -111,7 +118,7 @@ class PipeRpcClient(object):
                 err = msg.get("error") or {}
                 from .client import CfquantError
 
-                raise CfquantError(err.get("message") or str(err))
+                raise CfquantError(err.get("message") or str(err), details=err)
             return timing.decode(msg.get("result"), decode_value)
         except (KeyboardInterrupt, SystemExit):
             self.close()

{cfquant-0.2.54 → cfquant-0.2.56}/cfquant/protocol.py

@@ -215,10 +215,11 @@ def encode_error(error):
         return None
     if isinstance(error, dict):
         return error
-    return {
-        "type": type(error).__name__,
-        "message": str(error),
-    }
+    details = getattr(error, "error_details", None)
+    result = dict(details) if isinstance(details, dict) else {}
+    result.setdefault("type", type(error).__name__)
+    result["message"] = str(error)
+    return result
 
 
 def encode_value(value):

{cfquant-0.2.54 → cfquant-0.2.56}/cfquant/qmt_component_login.py

@@ -18,9 +18,12 @@ class QmtNotReady(RuntimeError):
 
 def verify_environment(directory):
     """Validate dependencies and native ABI before stopping a running terminal."""
-    import frida  # noqa: F401
-    import win32api
-    import win32crypt  # noqa: F401
+    try:
+        from .qmt_dependencies import LOGIN_MODULES, import_login_module
+    except ImportError:
+        from qmt_dependencies import LOGIN_MODULES, import_login_module
+    modules = {name: import_login_module(name) for name in LOGIN_MODULES}
+    win32api = modules["win32api"]
     directory = Path(directory)
     for module in ("Qt5Core.dll", "Qt5Widgets.dll"):
         version = win32api.GetFileVersionInfo(str(directory / module), "\\")
@@ -83,12 +86,16 @@ def select_binding(config_path, name):
 
 class QtLoginBackend:
     def __init__(self, directory, timeout=40, expected_pid=None):
-        import frida
+        try:
+            from .qmt_dependencies import import_login_module
+        except ImportError:
+            from qmt_dependencies import import_login_module
         import psutil
-        import win32api
-        import win32event
-        import win32gui
-        import win32process
+        frida = import_login_module("frida")
+        win32api = import_login_module("win32api")
+        win32event = import_login_module("win32event")
+        win32gui = import_login_module("win32gui")
+        win32process = import_login_module("win32process")
         self.gui, self.process = win32gui, win32process
         self.timeout = timeout
         self.hwnd = None
@@ -232,8 +239,12 @@ class QtLoginBackend:
         self.failure_hwnd = None
 
     def close(self):
-        import win32api
-        import win32event
+        try:
+            from .qmt_dependencies import import_login_module
+        except ImportError:
+            from qmt_dependencies import import_login_module
+        win32api = import_login_module("win32api")
+        win32event = import_login_module("win32event")
         try:
             if self.session:
                 self.session.detach()

{cfquant-0.2.54 → cfquant-0.2.56}/cfquant/qmt_credentials.py

@@ -6,6 +6,8 @@ import os
 from pathlib import Path
 import threading
 
+from .qmt_dependencies import QmtDependencyError, import_login_module
+
 _LOCK = threading.RLock()
 
 
@@ -17,12 +19,12 @@ def directory_key(directory):
 
 
 def _protect(value, entropy):
-    import win32crypt
+    win32crypt = import_login_module("win32crypt")
     return win32crypt.CryptProtectData(value, "CFQuant QMT login", entropy, None, None, 1)
 
 
 def _unprotect(value, entropy):
-    import win32crypt
+    win32crypt = import_login_module("win32crypt")
     return win32crypt.CryptUnprotectData(value, entropy, None, None, 1)[1]
 
 
@@ -50,6 +52,8 @@ class QmtCredentialStore:
         key = directory_key(directory)
         try:
             encrypted = _protect(password.encode("utf-8"), key.encode("ascii"))
+        except QmtDependencyError:
+            raise
         except Exception:
             raise RuntimeError("无法使用当前 Windows 用户加密 QMT 密码，请检查 pywin32 安装") from None
         with _LOCK:
@@ -68,5 +72,7 @@ class QmtCredentialStore:
             return ""
         try:
             return _unprotect(base64.b64decode(entry["secret"]), key.encode("ascii")).decode("utf-8")
+        except QmtDependencyError:
+            raise
         except Exception:
             raise RuntimeError("无法解密 QMT 密码，请使用保存密码时的 Windows 用户运行，或重新保存密码") from None

cfquant-0.2.56/cfquant/qmt_dependencies.py

@@ -0,0 +1,158 @@
+"""Read-only checks and repair instructions for optional QMT login components."""
+import copy
+import importlib
+import json
+import os
+import subprocess
+import sys
+import threading
+import time
+
+
+LOGIN_MODULES = ("frida", "win32api", "win32crypt", "win32event", "win32gui", "win32process")
+_LOCK = threading.Lock()
+_CACHE = {}
+_PROBE_CODE = r'''
+import importlib, importlib.metadata, json, os, pathlib, sys
+checks = []
+for name in MODULES:
+    try:
+        module = importlib.import_module(name)
+        checks.append(dict(name=name, ok=True, path=getattr(module, '__file__', '')))
+    except Exception as error:
+        checks.append(dict(name=name, ok=False, error=str(error), error_type=type(error).__name__))
+packages = {}
+for name in ('pywin32', 'frida'):
+    try:
+        packages[name] = importlib.metadata.version(name)
+    except importlib.metadata.PackageNotFoundError:
+        packages[name] = ''
+prefix = pathlib.Path(sys.prefix)
+base_prefix = pathlib.Path(getattr(sys, 'base_prefix', sys.prefix))
+conda = (prefix / 'conda-meta').is_dir()
+venv = not conda and prefix != base_prefix
+environment = 'conda' if conda else 'venv' if venv else 'python'
+print(json.dumps(dict(python_executable=sys.executable, python_version=sys.version.split()[0],
+    prefix=str(prefix), base_prefix=str(base_prefix), environment=environment,
+    global_python=sys.prefix == sys.base_prefix,
+    conda_executable=os.environ.get('CONDA_EXE', '') if conda else '',
+    conda_pywin32=conda and bool(list((prefix / 'conda-meta').glob('pywin32-*.json'))),
+    supported=sys.platform == 'win32', checks=checks, packages=packages), ensure_ascii=True))
+'''
+
+
+def _ps_quote(value):
+    return "'" + str(value).replace("'", "''") + "'"
+
+
+def _finish_report(report):
+    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", [])))
+    failed = [item for item in report.get("checks", []) if not item["ok"]]
+    if not report.get("supported") and not report.get("error"):
+        report["message"] = "当前系统不支持 QMT 组件自动登录，请手动启动并登录 QMT。"
+    elif report["ok"]:
+        report["message"] = "QMT 自动登录组件检测通过。"
+    else:
+        names = "、".join(item["name"] for item in failed) or "Python 环境"
+        report["message"] = "QMT 自动登录组件不可用（%s）。可取消自动启动，保存配置后手动启动并登录 QMT。" % names
+    commands = []
+    python = "& " + _ps_quote(report["python_executable"])
+    environment = str(report.get("environment") or "").lower()
+    if environment not in {"conda", "venv", "python"}:
+        environment = "python" if report.get("global_python") else "venv"
+    if report.get("supported") and failed:
+        if any(item["name"].startswith("win32") for item in failed):
+            if environment == "conda" and report.get("conda_pywin32"):
+                conda = report.get("conda_executable") or "conda"
+                commands.append("& %s install --prefix %s --force-reinstall 'pywin32>=306'" % (
+                    _ps_quote(conda), _ps_quote(report["prefix"])))
+            else:
+                commands.append(python + " -m pip install --no-cache-dir --upgrade --force-reinstall 'pywin32>=306'")
+                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')"))
+    report["repair_commands"] = commands
+    if environment == "conda":
+        report["repair_note"] = (
+            "已检测到 Conda 环境。先停止 CFQuant，在已激活该环境的 Anaconda Prompt 或 PowerShell 中执行；"
+            "命令会绑定当前环境的前缀。验证通过后重启 CFQuant，再重新检测。"
+        )
+    elif environment == "venv":
+        report["repair_note"] = (
+            "已检测到 venv 虚拟环境。先停止 CFQuant，在普通 PowerShell 中执行下面的命令；"
+            "命令已绑定当前 venv 的 Python，不要切换到系统 Python，也不要运行 pywin32_postinstall。"
+            "验证通过后重启 CFQuant，再重新检测。"
+        )
+    else:
+        report["repair_note"] = (
+            "已检测到独立 Python 环境。先停止 CFQuant，在 PowerShell 中执行下面的命令；"
+            "命令已绑定当前 Python，安装完成后会执行 pywin32_postinstall。"
+            "验证通过后重启 CFQuant，再重新检测。"
+        )
+    return report
+
+
+def check_login_dependencies(python_exe=None, refresh=False, timeout=15):
+    """Probe the actual interpreter without installing packages or loading DLLs here."""
+    executable = str(python_exe or sys.executable)
+    with _LOCK:
+        if not refresh and executable in _CACHE:
+            return copy.deepcopy(_CACHE[executable])
+        report = {"python_executable": executable, "supported": sys.platform == "win32", "checks": []}
+        if not report["supported"]:
+            _CACHE[executable] = _finish_report(report)
+            return copy.deepcopy(_CACHE[executable])
+        try:
+            run_kwargs = {}
+            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],
+                stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, encoding="utf-8",
+                errors="replace", timeout=timeout,
+                **run_kwargs,
+            )
+            if completed.returncode:
+                raise RuntimeError((completed.stderr or completed.stdout or "Python dependency probe failed")[-4000:])
+            # Startup hooks may print before our JSON report.
+            report.update(json.loads(completed.stdout.strip().splitlines()[-1]))
+        except Exception as error:
+            report["error"] = str(error)
+        _CACHE[executable] = _finish_report(report)
+        return copy.deepcopy(_CACHE[executable])
+
+
+class QmtDependencyError(RuntimeError):
+    pass
+
+
+def import_login_module(name):
+    """Keep in-process import errors actionable, including stale loaded DLLs."""
+    try:
+        return importlib.import_module(name)
+    except (ImportError, OSError) as error:
+        raise QmtDependencyError(
+            "QMT 自动登录组件 %s 无法加载；运行环境：%s；原因：%s。"
+            "请查看自动登录组件检测中的修复说明，或取消自动启动后手动登录 QMT。"
+            % (name, sys.executable, error)
+        ) from error
+
+
+def report_startup_dependencies(python_exe=None):
+    report = check_login_dependencies(python_exe, refresh=True)
+    if not report.get("supported"):
+        return report
+    level = "INFO" if report["ok"] else "WARN"
+    print("[%s] %s Python=%s" % (level, report["message"], report["python_executable"]))
+    for item in report["checks"]:
+        if not item["ok"]:
+            print("[WARN] %s: %s" % (item["name"], item["error"]))
+    if report.get("error"):
+        print("[WARN] %s" % report["error"])
+    for command in report["repair_commands"]:
+        print("[REPAIR] %s" % command)
+    return report

{cfquant-0.2.54 → cfquant-0.2.56}/cfquant/qmt_pipe_runtime.py

@@ -5,11 +5,23 @@ import os as _cq_os
 import sys as _cq_sys
 import threading as _cq_threading
 import time as _cq_time
+import uuid as _cq_uuid
+
+
+class ManagedStrategyError(RuntimeError):
+    """A rejection made before entering any QMT business dispatcher."""
+
+    def __init__(self, message, code, runtime_instance_id, retry_when=""):
+        super(ManagedStrategyError, self).__init__(message)
+        self.error_details = dict(code=code, stage="before_dispatch", dispatched=False,
+                                  safe_to_retry=bool(retry_when), retry_when=retry_when,
+                                  runtime_instance_id=runtime_instance_id)
 
 
 class ManagedPipeRuntime(object):
     def __init__(self, descriptor=None):
         self.descriptor = dict(descriptor or {})
+        self.runtime_instance_id = _cq_uuid.uuid4().hex
         self.active = False
         self.approved = False
         self.revoked = False
@@ -49,7 +61,8 @@ class ManagedPipeRuntime(object):
         state = "error" if self.failure else ("stopped" if not self.active or self.revoked
                                               else ("running" if ready and self.approved else "loaded"))
         return dict(self.descriptor, state=state, error=self.failure,
-                    pid=_cq_os.getpid(), updated_at=_cq_time.time())
+                    pid=_cq_os.getpid(), updated_at=_cq_time.time(),
+                    runtime_instance_id=self.runtime_instance_id)
 
     def control(self, desired):
         if desired.get("runtime_key") != self.descriptor.get("runtime_key"):
@@ -78,9 +91,18 @@ class ManagedPipeRuntime(object):
                 return self.control(params or {})
             if action == "cfquant.status":
                 return function(action, params, msg)
-            if not self.approved:
-                raise RuntimeError("Managed strategy is awaiting account mode confirmation from cfquant Web.")
-            return dispatch_request(action, params, msg)
+            with self.mutex:
+                if not self.active or self.revoked:
+                    raise ManagedStrategyError("The account's cfquant strategy mode has changed.",
+                                               "STRATEGY_MODE_CHANGED", self.runtime_instance_id)
+                if not self.approved:
+                    raise ManagedStrategyError(
+                        "Managed strategy is awaiting account mode confirmation from cfquant Web.",
+                        "ACCOUNT_MODE_UNCONFIRMED", self.runtime_instance_id, "account_ready")
+            result = dispatch_request(action, params, msg)
+            if action == "cfquant.ping" and isinstance(result, dict):
+                result = dict(result, managed_runtime=self.status())
+            return result
         return guarded
 
     def wrap(self, function, reject=False):
@@ -89,7 +111,8 @@ class ManagedPipeRuntime(object):
             with self.mutex:
                 if not self.active or self.revoked:
                     if reject:
-                        raise RuntimeError("The account's cfquant strategy mode has changed.")
+                        raise ManagedStrategyError("The account's cfquant strategy mode has changed.",
+                                                   "STRATEGY_MODE_CHANGED", self.runtime_instance_id)
                     return None
                 self.calls += 1
             try: