cfquant 0.2.66__tar.gz → 0.2.67__tar.gz

{cfquant-0.2.66 → cfquant-0.2.67}/MANIFEST.in

@@ -6,7 +6,12 @@ include cfquant_pipe_hub.py
 recursive-include cfquant *.py
 include cfquant/qmt_component_agent.js
 include cfquant/qmt_strategy_agent.js
+include cfquant/qmt_vm_agent.js
+include cfquant/qmt_mac_agent.js
+include cfquant/tools/THIRD_PARTY.md
+recursive-include cfquant/tools/upx *
 recursive-include cfquant/tests *.py *.md
+include cfquant/tests/qmt_vm_native_fixture.js
 recursive-include LTtx *.py
 include LTtx/tx/Config.txt
 

{cfquant-0.2.66 → cfquant-0.2.67}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.66
+Version: 0.2.67
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8
@@ -17,6 +17,7 @@ Requires-Dist: pandas-market-calendars
 Requires-Dist: importlib-resources>=5
 Requires-Dist: frida==17.16.4; sys_platform == "win32"
 Requires-Dist: pywin32>=306; sys_platform == "win32"
+Requires-Dist: pefile>=2023.2.7; sys_platform == "win32"
 Provides-Extra: dev
 Requires-Dist: build>=1.0; extra == "dev"
 Requires-Dist: twine>=5.0; extra == "dev"
@@ -403,6 +404,7 @@ restart_cfquant.bat     重启
 | 极致模式部署 | [极致模式部署指南](docs/极致模式部署指南.md) |
 | 高级模式部署 | [高级模式部署指南](docs/高级模式部署指南.md) |
 | 账号和 QMT 目录配置 | [Web 账号运行配置说明](docs/Web账号运行配置说明.md) |
+| 虚拟机检测适配与 MAC 注入 | [QMT 启动设置](docs/qmt_launch_settings.md)，按绑定配置，默认关闭 |
 | 从 miniQMT 迁移 | [miniQMT 迁移到大 QMT 指南](docs/miniQMT迁移到大QMT指南.md) |
 | 官网 nativeApi 接口功能及适配状态 | [xtquant 原版接口适配清单](docs/xtquant原版接口适配清单.md) |
 | Level2 六类行情、订阅回调与千档边界 | [Level2 行情适配说明](docs/Level2行情适配说明.md) |

{cfquant-0.2.66 → cfquant-0.2.67}/README.md

@@ -378,6 +378,7 @@ restart_cfquant.bat     重启
 | 极致模式部署 | [极致模式部署指南](docs/极致模式部署指南.md) |
 | 高级模式部署 | [高级模式部署指南](docs/高级模式部署指南.md) |
 | 账号和 QMT 目录配置 | [Web 账号运行配置说明](docs/Web账号运行配置说明.md) |
+| 虚拟机检测适配与 MAC 注入 | [QMT 启动设置](docs/qmt_launch_settings.md)，按绑定配置，默认关闭 |
 | 从 miniQMT 迁移 | [miniQMT 迁移到大 QMT 指南](docs/miniQMT迁移到大QMT指南.md) |
 | 官网 nativeApi 接口功能及适配状态 | [xtquant 原版接口适配清单](docs/xtquant原版接口适配清单.md) |
 | Level2 六类行情、订阅回调与千档边界 | [Level2 行情适配说明](docs/Level2行情适配说明.md) |

{cfquant-0.2.66 → cfquant-0.2.67}/cfquant/batch_orders.py

@@ -7,7 +7,7 @@ import time
 from collections.abc import Mapping
 from numbers import Integral, Real
 from .stock_connect import normalize_connect_code, validate_connect_market
-from .order_identity import prepare_order_remark, order_remark_key
+from .order_identity import prepare_order_remark, order_remark_key, restore_order_remark
 
 
 CFTRADER_BATCH_ORDER_ACTIONS = frozenset(("cftrader.order_stock_batch", "cftrader.order_stock_batch_async"))
@@ -203,6 +203,9 @@ def batch_cancel_result_rows(cancels, seqs=None):
 
 
 def batch_result(account, batch_id, asynchronous, results, operation="order"):
+    if operation == "order":
+        for row in results:
+            restore_order_remark(row)
     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)

{cfquant-0.2.66 → cfquant-0.2.67}/cfquant/order_identity.py

@@ -72,6 +72,14 @@ def restore_order_remark(data):
         if is_unique_order_remark(internal):
             data["cfquant_order_remark"] = internal
             data["order_remark"] = original_order_remark(internal)
+            submission_id = _ORDER_REMARK_SUFFIX.search(internal).group(1)
+            data["cfquant_submission_id"] = submission_id
+            # The native remark identifies one submission, which QMT may split.
+            # Derive the child key from the final public ID, never list position.
+            data.pop("cfquant_child_id", None)
+            order_id = str(data.get("order_id") or "").strip()
+            if order_id.isdigit() and int(order_id) > 0:
+                data["cfquant_child_id"] = submission_id + ":" + str(int(order_id))
     return data
 
 
@@ -153,7 +161,7 @@ class OrderCallbackCache(object):
             matches = self._matches(scope, refs, data)
             remark = order_remark_key(data)
             local = sorted(ref for ref in refs if ref[0] == "local")
-            identity = ("remark", remark) if is_unique_order_remark(remark) else (local or sorted(refs))[0]
+            identity = (local or sorted(refs))[0]
             key = (scope, identity)
             if len(matches) == 1:
                 key = matches[0]
@@ -187,4 +195,22 @@ class OrderCallbackCache(object):
                     data[name] = value
             if is_unique_order_remark(remark):
                 data["cfquant_order_remark"] = remark
+            # A broker-only DEAL can recover its child from this typed index.
+            # Shared submission metadata alone cannot choose that child.
+            order_id = str(data.get("order_id") or "").strip()
+            if not (order_id.isdigit() and int(order_id) > 0):
+                saved_id = saved.get("order_id")
+                if str(saved_id or "").isdigit() and int(saved_id) > 0:
+                    data["order_id"] = int(saved_id)
         return restore_order_remark(data)
+
+    def submission_is_ambiguous(self, data, account_type):
+        """Missing child IDs must not fall back to a split submission's first ID."""
+        with self.lock:
+            scope, _ = self._identity(data, account_type)
+            remark = order_remark_key(data)
+            ids = {str(record["data"].get("order_id")) for key, record in self.records.items()
+                   if key[0] == scope and order_remark_key(record["data"]) == remark
+                   and str(record["data"].get("order_id") or "").isdigit()
+                   and int(record["data"]["order_id"]) > 0}
+            return len(ids) > 1

{cfquant-0.2.66 → cfquant-0.2.67}/cfquant/order_meta.py

@@ -27,6 +27,7 @@ DEFAULT_BRIDGE_ID = "default"
 DEFAULT_ACCOUNT_TYPE = "STOCK"
 PENDING_MATCH_TTL_SECONDS = 10 * 60
 CANONICAL_ORDER_ID_FIELD = "canonical_order_id"
+ORDER_IDENTITY_VERSION = 2
 ORDER_REF_FIELDS = (
     "order_ref",
     "m_strOrderRef",
@@ -165,6 +166,42 @@ def reconcile_order_id(data, order_id):
     return mismatched
 
 
+def native_order_id(data):
+    for name in ("m_nRef", "m_nOrderID", "m_strOrderRef", "m_strOrderID", "order_id"):
+        value = positive_order_id(data.get(name))
+        if value is not None:
+            return value
+    return None
+
+
+def same_broker_order(record, data):
+    """Only child-scoped, versioned broker evidence can justify a local alias."""
+    if record.get("order_identity_version") != ORDER_IDENTITY_VERSION:
+        return False
+    left = normalize_order_ref(first_value(record, ("order_sysid", "m_strOrderSysID")))
+    right = normalize_order_ref(first_value(data, ("order_sysid", "m_strOrderSysID")))
+    left_stock = normalize_text(record.get("stock_code")).upper()
+    right_stock = normalize_text(data.get("stock_code")).upper()
+    return bool(left and left == right and left_stock and left_stock == right_stock)
+
+
+def verified_child_alias(record, data):
+    return (record.get("order_identity_version") == ORDER_IDENTITY_VERSION
+            and native_order_id(data) in (record.get("child_local_ids") or [])) or same_broker_order(record, data)
+
+
+def submission_metadata(record):
+    """Copy shared text/context without carrying a sibling's identity or size."""
+    result = dict(record)
+    for name in ORDER_REF_FIELDS + ("order_refs", CANONICAL_ORDER_ID_FIELD,
+                                    "callback_bound_at", "order_volume", "order_identity_version", "child_local_ids",
+                                    "query_order_id",
+                                    "cfquant_child_id", "cfquant_callback_order_id",
+                                    "cfquant_order_id_reconciled"):
+        result.pop(name, None)
+    return result
+
+
 def stock_code_base(value):
     text = normalize_text(value)
     if not text:
@@ -413,6 +450,13 @@ def apply_record_to_callback(data, record, match_info=None):
         data["client_order_id"] = normalize_text(record.get("client_order_id"))
 
     order_id = canonical_order_id_from_record(record)
+    native_id = native_order_id(data)
+    if native_id is not None and (
+        (match_info or {}).get("preserve_order_id")
+        or (is_unique_order_remark(user_order_id) and native_id != order_id
+            and not verified_child_alias(record, data))
+    ):
+        order_id = native_id
     if order_id is not None:
         reconcile_order_id(data, order_id)
         order_id_ref = str(order_id)
@@ -511,6 +555,19 @@ class OrderMetaCache(object):
             return self._upsert_locked(record)
 
     def _upsert_locked(self, record):
+        if (is_unique_order_remark(user_order_id_from_data(record))
+                and record.get("order_identity_version") != ORDER_IDENTITY_VERSION):
+            # Old stores may have merged sibling IDs/sysids into one record.
+            # Retain submission metadata and its canonical ID, not unproven aliases.
+            canonical = canonical_order_id_from_record(record)
+            volume = record.get("order_volume")
+            record = submission_metadata(record)
+            if volume is not None:
+                record["order_volume"] = volume
+            if canonical is not None:
+                record.update(order_id=canonical, canonical_order_id=canonical,
+                              order_ref=str(canonical), order_refs=[str(canonical)])
+            record["order_identity_version"] = ORDER_IDENTITY_VERSION
         trade_day = current_trade_day()
         self._prune_locked(trade_day, time.time())
         status = normalize_text(record.get("status")).lower()
@@ -594,13 +651,18 @@ class OrderMetaCache(object):
             loaded += 1
         return {"loaded": loaded, "stale": stale}
 
-    def resolve_callback(self, data, bridge_id=None, account_type=None, account_id=None, allow_pending=True):
+    def resolve_callback(self, data, bridge_id=None, account_type=None, account_id=None, allow_pending=True,
+                         query=False):
         callback_record = normalize_record(
             data,
             bridge_id=bridge_id or self.bridge_id,
             account_type=account_type or data.get("account_type"),
             account_id=account_id or data.get("account_id"),
         )
+        # normalize_record also accepts stores and synthesizes m_strOrderRef
+        # from any reference, including a broker sysid. It is not native evidence.
+        if "m_strOrderRef" not in data:
+            callback_record.pop("m_strOrderRef", None)
         with self.lock:
             self._prune_locked(current_trade_day(), time.time())
             record = None
@@ -612,6 +674,13 @@ class OrderMetaCache(object):
                 if record and user_order_id and is_unique_order_remark(user_order_id_from_data(record)):
                     if not order_remark_matches_reference(user_order_id_from_data(record), user_order_id):
                         record = None
+                if record and is_unique_order_remark(user_order_id_from_data(record)):
+                    native_id = native_order_id(callback_record)
+                    if not ((native_id is not None and native_id == canonical_order_id_from_record(record))
+                            or verified_child_alias(record, callback_record)):
+                        # Numeric local IDs and broker IDs share the legacy
+                        # index. An untyped string hit is not child evidence.
+                        record = None
                 if record:
                     confidence = "order_ref"
                     break
@@ -624,11 +693,14 @@ class OrderMetaCache(object):
                         record = None
                 if record:
                     confidence = "user_order_id"
-            if record is None and allow_pending:
+            if record is None and allow_pending and not query:
                 record, confidence = self._match_pending_locked(callback_record)
-            if record is None:
+            if record is None and not query:
                 record, confidence = self._match_known_locked(callback_record, order_refs)
 
+            if record and is_unique_order_remark(user_order_id_from_data(record)):
+                record = self._resolve_child_locked(record, callback_record, confidence, query)
+
             bound_order_ref = ""
             bound_order_refs = []
             if record and order_refs:
@@ -652,8 +724,56 @@ class OrderMetaCache(object):
                 "bound_order_ref": bound_order_ref,
                 "bound_order_refs": bound_order_refs,
                 "match_confidence": confidence,
+                "preserve_order_id": query,
             }
 
+    def _resolve_child_locked(self, record, data, confidence, query):
+        """A UUID groups submissions; native IDs partition the real children."""
+        incoming_id = native_order_id(data)
+        canonical = canonical_order_id_from_record(record)
+        broker_matches = []
+        if same_broker_order(record, data):
+            broker_matches = [item for item in self._unique_records_locked()
+                              if self._ctx(item) == self._ctx(record) and same_broker_order(item, data)]
+        broker_ambiguous = len({canonical_order_id_from_record(item) for item in broker_matches}) > 1
+        if incoming_id is None:
+            broker_id = normalize_order_ref(first_value(data, ("order_sysid", "m_strOrderSysID")))
+            if broker_id and (broker_ambiguous or not same_broker_order(record, data)):
+                return submission_metadata(record)
+            if confidence == "user_order_id":
+                key = self._user_key(record)
+                children = {canonical_order_id_from_record(item) for item in self._unique_records_locked()
+                            if self._user_key(item) == key}
+                children.discard(None)
+                if len(children) > 1:
+                    return submission_metadata(record)
+            return record
+        same_child = incoming_id == canonical or verified_child_alias(record, data)
+        if broker_ambiguous and incoming_id != canonical and incoming_id not in (record.get("child_local_ids") or []):
+            same_child = False
+        if query and record.get("query_order_id") not in (None, incoming_id):
+            # Two ORDER query rows are separate children even if the broker
+            # uses the same reference. Only callback references can be aliases.
+            same_child = False
+        if not same_child:
+            record = submission_metadata(record)
+        else:
+            record = dict(record)
+        # Queries provide the authoritative local order ID. A callback alias
+        # may reuse it only after matching a broker ID recorded for this child.
+        child_id = canonical if same_child and canonical is not None and not query else incoming_id
+        record.update(order_id=child_id, canonical_order_id=child_id,
+                      order_identity_version=ORDER_IDENTITY_VERSION)
+        record["child_local_ids"] = sorted(set((record.get("child_local_ids") or []) + [child_id, incoming_id]))
+        if query:
+            record["query_order_id"] = incoming_id
+        if not same_child:
+            record.update(order_ref=str(child_id), order_refs=[str(child_id)])
+        for name in ("order_sysid", "m_strOrderSysID", "order_volume"):
+            if not is_empty(data.get(name)):
+                record[name] = data[name]
+        return record
+
     def _unique_records_locked(self):
         records = []
         seen = set()
@@ -683,6 +803,11 @@ class OrderMetaCache(object):
                 continue
             if not self._has_callback_metadata(record):
                 continue
+            if is_unique_order_remark(user_order_id_from_data(record)):
+                native_id = native_order_id(callback_record)
+                if not ((native_id is not None and native_id == canonical_order_id_from_record(record))
+                        or verified_child_alias(record, callback_record)):
+                    continue
             evidence = self._context_match_evidence(record, callback_record)
             if evidence < 0:
                 continue

cfquant-0.2.67/cfquant/qmt_mac_agent.js

@@ -0,0 +1,87 @@
+'use strict';
+
+// Windows x64 iptypes.h layouts. Only buffers returned to this QMT's utils.dll
+// are changed; the OS interfaces and all other processes retain their own data.
+const macLayouts = {
+  GetAdaptersInfo: {bufferArg: 0, sizeArg: 1, next: 0, length: 404, address: 408, minimum: 416},
+  GetAdaptersAddresses: {bufferArg: 3, sizeArg: 4, next: 8, length: 88, address: 80, minimum: 92}
+};
+const macListeners = [];
+const macCalls = {};
+
+function rewriteMacList(buffer, size, layout, bytes) {
+  if (buffer.isNull() || size < layout.minimum || size > 16 * 1024 * 1024) {
+    throw new Error('Invalid adapter buffer bounds');
+  }
+  const end = buffer.add(size);
+  const seen = new Set();
+  const addresses = [];
+  let node = buffer;
+  while (!node.isNull()) {
+    if (seen.size >= 512 || seen.has(node.toString()) || node.compare(buffer) < 0 ||
+        node.add(layout.minimum).compare(end) > 0) {
+      throw new Error('Invalid adapter linked list');
+    }
+    seen.add(node.toString());
+    if (layout === macLayouts.GetAdaptersAddresses &&
+        (node.readU32() < layout.minimum || node.add(node.readU32()).compare(end) > 0)) {
+      throw new Error('Unexpected IP_ADAPTER_ADDRESSES length');
+    }
+    const length = node.add(layout.length).readU32();
+    if (length > 8) throw new Error('Invalid hardware address length');
+    if (length === 6) addresses.push(node.add(layout.address));
+    node = node.add(layout.next).readPointer();
+  }
+  // Validate the whole result before making changes.
+  for (const address of addresses) address.writeByteArray(bytes);
+  return addresses.length;
+}
+
+function disposeMac() {
+  for (const listener of macListeners) listener.detach();
+  macListeners.length = 0;
+}
+
+rpc.exports.configuremac = function (directory, mac) {
+  if (Process.platform !== 'windows' || Process.arch !== 'x64') throw new Error('Windows x64 required');
+  if (macListeners.length) throw new Error('MAC listeners already installed');
+  if (!/^(?:[0-9A-F]{2}-){5}[0-9A-F]{2}$/.test(mac)) throw new Error('Invalid MAC format');
+  const bytes = mac.split('-').map(value => parseInt(value, 16));
+  if ((bytes[0] & 1) || bytes.every(value => value === 0)) throw new Error('Unicast MAC required');
+  const normalize = value => value.replace(/\//g, '\\').replace(/\\+$/, '').toLowerCase();
+  const expected = normalize(directory) + '\\utils.dll';
+  const iphlp = Process.getModuleByName('iphlpapi.dll');
+  iphlp.ensureInitialized();
+  try {
+    for (const [name, layout] of Object.entries(macLayouts)) {
+      macCalls[name] = 0;
+      macListeners.push(Interceptor.attach(iphlp.getExportByName(name), {
+        onEnter(args) {
+          const caller = Process.findModuleByAddress(this.returnAddress);
+          this.applies = Boolean(caller && normalize(caller.path) === expected);
+          if (!this.applies) return;
+          this.buffer = args[layout.bufferArg];
+          this.sizePointer = args[layout.sizeArg];
+          this.capacity = this.sizePointer.isNull() ? 0 : this.sizePointer.readU32();
+        },
+        onLeave(retval) {
+          if (!this.applies || retval.toUInt32() !== 0 || this.buffer.isNull() || this.sizePointer.isNull()) return;
+          try {
+            const size = Math.min(this.capacity, this.sizePointer.readU32());
+            const count = rewriteMacList(this.buffer, size, layout, bytes);
+            macCalls[name]++;
+            if (macCalls[name] === 1) send({event: 'mac_override', api: name, adapters: count});
+          } catch (error) {
+            send({event: 'mac_error', api: name, detail: String(error)});
+          }
+        }
+      }));
+    }
+    return {ready: true, apis: Object.keys(macLayouts)};
+  } catch (error) {
+    disposeMac();
+    throw error;
+  }
+};
+rpc.exports.macstatus = function () { return {active: macListeners.length === 2, calls: macCalls}; };
+rpc.exports.disposemac = disposeMac;

{cfquant-0.2.66 → cfquant-0.2.67}/cfquant/qmt_python_runtime.py

@@ -89,14 +89,10 @@ def _version_tuple(value):
     different files.  Unknown values deliberately return ``None`` so callers
     can choose the conservative py36 runtime.
     """
-    parts = re.findall(r"\d+", str(value or ""))
-    if not parts:
+    match = re.fullmatch(r"\s*(\d+)\.(\d+)\.(\d+)(?:\.(\d+))?\s*", str(value or ""))
+    if not match:
         return None
-    try:
-        numbers = [int(part) for part in parts[:4]]
-    except ValueError:
-        return None
-    return tuple((numbers + [0, 0, 0, 0])[:4])
+    return tuple(int(part or 0) for part in match.groups())
 
 
 class QmtPythonRuntime:
@@ -288,6 +284,8 @@ class QmtPythonRuntime:
         # binding on the native/default py36 runtime until it is verified.
         if configured_runtime:
             selected = configured_runtime if py312_supported or configured_runtime == "py36" else "py36"
+        elif not py312_supported:
+            selected = "py36"
         inspected = {
             runtime: self.inspect(runtime, refresh_remote=False)
             for runtime in ("py36", "py312")
@@ -526,6 +524,9 @@ class QmtPythonRuntime:
         account = str(account_id if account_id is not None else self.account_id) if (account_id is not None or self.account_id is not None) else None
         if not account:
             raise QmtPythonRuntimeError("account_id is required to switch QMT Python runtime")
+        self.validate_selection(runtime, account_id=account)
+        if not self.inspect(runtime, refresh_remote=False)["installed"]:
+            raise QmtPythonRuntimeError("QMT Python library is not installed: %s" % runtime)
         config = self.qmt_dir / "userdata" / "users" / account / "Config.xml"
         if not config.is_file():
             raise QmtPythonRuntimeError("QMT account Config.xml not found: %s" % account)
@@ -533,13 +534,16 @@ class QmtPythonRuntime:
         path_value = (self.bin_dir / "python312" if runtime == "py312" else self.bin_dir).as_posix()
         if not re.search(r"<python\b[^>]*>", text):
             raise QmtPythonRuntimeError("QMT account Config.xml has no python settings")
-        updated = re.sub(r'(<python\b[^>]*\blibs_path=")[^"]*(")', r'\g<1>' + path_value + r'\2', text, count=1)
-        if updated == text:
+        if not re.search(r'<python\b[^>]*\blibs_path="[^"]*"', text):
             raise QmtPythonRuntimeError("cannot update QMT python libs_path")
+        updated = re.sub(r'(<python\b[^>]*\blibs_path=")[^"]*(")', r'\g<1>' + path_value + r'\2', text, count=1)
         if re.search(r'(<python\b[^>]*\bm_nPythonVersion=")[^"]*(")', updated):
             updated = re.sub(r'(<python\b[^>]*\bm_nPythonVersion=")[^"]*(")', r'\g<1>' + ("1" if runtime == "py312" else "0") + r'\2', updated, count=1)
         else:
             updated = re.sub(r'(<python\b)', r'\1 m_nPythonVersion="%s"' % ("1" if runtime == "py312" else "0"), updated, count=1)
+        if updated == text:
+            return {"account_id": account, "runtime": runtime, "config": str(config),
+                    "backup": None, "libs_path": path_value, "unchanged": True}
         self.backup_dir.mkdir(parents=True, exist_ok=True)
         backup = self.backup_dir / ("Config-%s-%s.xml" % (account, time.strftime("%Y%m%d-%H%M%S")))
         shutil.copy2(config, backup)
@@ -589,31 +593,49 @@ class QmtPythonRuntime:
             time.sleep(0.25)
         raise QmtPythonRuntimeError("QMT did not start after runtime switch")
 
+    def validate_selection(self, runtime, *, account_id=None):
+        runtime = _canonical_runtime(runtime)
+        effective_account = account_id if account_id is not None else self.account_id
+        binding = self.binding_status(account_id=effective_account)
+        if runtime == "py312" and not binding["py312_supported"]:
+            raise QmtPythonRuntimeError(
+                "QMT %s only supports the default py36 runtime; py312 is unavailable"
+                % (binding.get("qmt_version") or "unknown"))
+        if effective_account:
+            if not binding["config_exists"]:
+                raise QmtPythonRuntimeError("QMT account Config.xml not found: %s; log in to QMT first" % effective_account)
+            text = Path(binding["config"]).read_text(encoding="utf-8")
+            if not re.search(r'<python\b[^>]*\blibs_path="[^"]*"', text):
+                raise QmtPythonRuntimeError("QMT account Config.xml has no Python library settings")
+        return binding
+
     def download_and_switch(self, runtime="py312", *, restart=True, account_id=None,
                             progress_callback=None, cancel_event=None,
-                            restart_callback=None):
+                            restart_callback=None, reuse_installed=False):
         runtime = _canonical_runtime(runtime)
-        effective_account = account_id if account_id is not None else self.account_id
-        if runtime == "py312" and effective_account:
-            binding = self.binding_status(account_id=effective_account)
-            if not binding["py312_supported"]:
-                version = binding.get("qmt_version") or "unknown"
-                raise QmtPythonRuntimeError(
-                    "QMT %s only supports the default py36 runtime; py312 is unavailable" % version
-                )
-        package = self.fetch_package(runtime)
-        archive = self.download(runtime, package=package, progress_callback=progress_callback,
-                                cancel_event=cancel_event)
+        binding = self.validate_selection(runtime, account_id=account_id)
+        reuse = bool(reuse_installed and binding["runtimes"][runtime]["installed"])
+        package, archive = None, None
+        if reuse:
+            _callback(progress_callback, QmtPythonProgress(runtime, "reusing", message="Python 库已安装，准备切换执行器"))
+        else:
+            package = self.fetch_package(runtime)
+            archive = self.download(runtime, package=package, progress_callback=progress_callback,
+                                    cancel_event=cancel_event)
+        if cancel_event and cancel_event.is_set():
+            raise QmtPythonRuntimeError("QMT Python runtime operation cancelled")
+        _callback(progress_callback, QmtPythonProgress(runtime, "activating", message="正在停止 QMT 并配置执行器"))
         if restart and self._qmt_processes():
             self._stop_for_switch()
         elif not restart and self._qmt_processes():
             raise QmtPythonRuntimeError(
                 "QMT is running; set restart=True before activating a Python runtime")
         try:
-            installed = self.install(runtime, package=package, progress_callback=progress_callback)
+            installed = self.inspect(runtime, refresh_remote=False) if reuse else self.install(runtime, package=package, progress_callback=progress_callback)
             switched = self.switch_account(runtime, account_id=account_id) if (account_id or self.account_id) else None
         finally:
             if restart:
+                _callback(progress_callback, QmtPythonProgress(runtime, "restarting", message="正在重新启动 QMT"))
                 if restart_callback:
                     restarted = restart_callback()
                 elif self._qmt_processes():
@@ -622,7 +644,8 @@ class QmtPythonRuntime:
                     restarted = self.restart_qmt()
             else:
                 restarted = None
-        return {"runtime": runtime, "package": package.as_dict(), "archive": str(archive),
+        return {"runtime": runtime, "package": package.as_dict() if package else None,
+                "archive": str(archive) if archive else None, "reused_installed": reuse,
                 "installed": installed, "switched": switched, "restarted": restarted}
 
     def _stop_for_switch(self):

{cfquant-0.2.66 → cfquant-0.2.67}/cfquant/qmt_update.py

@@ -135,7 +135,7 @@ def same_path(left, right):
 
 
 class UpdateProcesses:
-    def __init__(self, directory, pid):
+    def __init__(self, directory, pid, launch_client=None):
         import psutil
         self.psutil = psutil
         self.directory = Path(directory).resolve()
@@ -148,6 +148,7 @@ class UpdateProcesses:
         self.owners = {}  # PID -> (creation time, installer flag)
         self.native = NativeDialogs()
         self.launch = None
+        self.launch_client = launch_client
 
     @property
     def pid(self):
@@ -218,7 +219,18 @@ class UpdateProcesses:
             new = matches[0]
             if new.create_time() <= self.started:
                 raise QmtUpdateError("update_process_changed")
-        else:
+            if self.launch_client is not None:
+                # Installer-started terminals have not received launch hooks.
+                new.terminate()
+                try:
+                    new.wait(timeout=10)
+                except self.psutil.TimeoutExpired:
+                    raise QmtUpdateError("update_restart_failed") from None
+                matches = []
+        if not matches and self.launch_client is not None:
+            self.launch = self.launch_client()
+            new = self.psutil.Process(int(self.launch['pid']))
+        elif not matches:
             self.launch = subprocess.Popen([str(self.exe)], cwd=str(self.directory))
             new = self.psutil.Process(self.launch.pid)
         self.qmt = new
@@ -325,14 +337,15 @@ class UpdateMonitor:
 
 def manage_qmt_startup(directory, pid, login, *, auto_update=False,
                        should_cancel=lambda: False, on_wait=lambda phase: None,
-                       on_pid=lambda pid: None):
+                       on_pid=lambda pid: None, launch_client=None):
     """Supervise update/restart and rerun login only for the resulting new PID.
 
     login is None for a client with its own automatic login; no Qt injection or
     credential access happens in that mode. The worker continues observing the
     updater after login so its late dialogs cannot be left blocking the client.
     """
-    processes = UpdateProcesses(directory, pid)
+    processes = (UpdateProcesses(directory, pid, launch_client=launch_client) if launch_client is not None
+                 else UpdateProcesses(directory, pid))
     monitor = UpdateMonitor(processes, auto_update, should_cancel, on_wait, on_pid)
     while not should_cancel():
         try: