cfquant 0.2.41__tar.gz → 0.2.42__tar.gz

{cfquant-0.2.41 → cfquant-0.2.42}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.41
+Version: 0.2.42
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8

{cfquant-0.2.41 → cfquant-0.2.42}/cfquant/normal_bridge.py

@@ -4,6 +4,7 @@ import hashlib
 import json
 import os
 import queue
+import re
 import threading
 import time
 
@@ -91,6 +92,8 @@ class NormalQmtBridge(TxTradeBridge):
         self.callback_asset_dedupe_max = 4096
         self.order_terminal_statuses = {}
         self.order_terminal_statuses_lock = threading.RLock()
+        self.pending_order_errors = []
+        self.pending_order_errors_lock = threading.RLock()
 
     def start(self):
         if self.running:
@@ -141,6 +144,7 @@ class NormalQmtBridge(TxTradeBridge):
         self._publish_runtime_report("context_ready")
 
     def close(self):
+        self._flush_pending_order_errors(force=True)
         self.running = False
         self.worker_event.set()
         self._close_quote_subscriptions()
@@ -627,6 +631,7 @@ class NormalQmtBridge(TxTradeBridge):
 
     def on_timer(self, *args, **kwargs):
         self._maybe_reset_order_meta_stores()
+        self._flush_pending_order_errors()
         if self.dispatch_on_qmt_thread:
             self._drain_requests("timer")
             return
@@ -844,10 +849,13 @@ class NormalQmtBridge(TxTradeBridge):
     def publish_callback_event(self, event_name, obj):
         if self.tx is None:
             return
+        force_order_error = isinstance(obj, dict) and obj.pop("_cfquant_force_order_error", False)
+        reconciled_order_error = None
         if event_name == "trader:on_stock_order":
             data = self._format_trade_detail(obj, "order")
             if not self._accept_order_callback(data):
                 return
+            reconciled_order_error = self._match_pending_order_error(data)
         elif event_name == "trader:on_stock_trade":
             data = self._format_trade_detail(obj, "deal")
         else:
@@ -860,6 +868,11 @@ class NormalQmtBridge(TxTradeBridge):
             data.setdefault("account_id", account_id)
         if account_type:
             data.setdefault("account_type", account_type)
+        if event_name == "trader:on_order_error":
+            self._enrich_qmt_order_error_fields(data)
+            if not force_order_error:
+                self._queue_pending_order_error(data)
+                return
         if event_name in (
             "trader:on_stock_order",
             "trader:on_stock_trade",
@@ -915,6 +928,115 @@ class NormalQmtBridge(TxTradeBridge):
             "normal bridge callback event sent event=%s account=%s channel_sent=%s clients=%s duplicate=%s"
             % (event_name, account_id or "-", not channel_duplicate, sent_clients, channel_duplicate and sent_clients == 0)
         )
+        if reconciled_order_error is not None:
+            reconciled_order_error.update({
+                "order_id": data.get("order_id", -1),
+                "m_nOrderID": data.get("m_nOrderID", data.get("order_id", -1)),
+                "m_nRef": data.get("m_nRef", data.get("order_id", -1)),
+                "order_sysid": data.get("order_sysid", ""),
+                "stock_code": data.get("stock_code", reconciled_order_error.get("stock_code", "")),
+                "_cfquant_force_order_error": True,
+            })
+            self.publish_callback_event("trader:on_order_error", reconciled_order_error)
+
+    def _queue_pending_order_error(self, data):
+        with self.pending_order_errors_lock:
+            self.pending_order_errors.append({"data": dict(data), "created_at": time.time()})
+
+    def _match_pending_order_error(self, order):
+        if not isinstance(order, dict):
+            return None
+        account = str(order.get("account_id") or "").strip()
+        code = str(order.get("stock_code") or "").upper().split(".", 1)[0]
+        strategy = str(order.get("strategy_name") or "")
+        remark = str(order.get("order_remark") or "")
+        with self.pending_order_errors_lock:
+            for index, item in enumerate(self.pending_order_errors):
+                error = item.get("data") or {}
+                error_account = str(error.get("account_id") or "").strip()
+                error_code = str(error.get("stock_code") or "").upper().split(".", 1)[0]
+                if account and error_account and account != error_account:
+                    continue
+                if code and error_code and code != error_code:
+                    continue
+                error_strategy = str(error.get("strategy_name") or error.get("strategyName") or "")
+                if error_strategy and strategy and error_strategy != strategy and not strategy.startswith(error_strategy + "&&&"):
+                    continue
+                error_remark = str(error.get("order_remark") or error.get("m_strRemark") or "")
+                if error_remark and remark and error_remark != remark:
+                    continue
+                self.pending_order_errors.pop(index)
+                return error
+        return None
+
+    def _flush_pending_order_errors(self, force=False):
+        cutoff = time.time() - 0.5 if not force else time.time() + 1.0
+        expired = []
+        with self.pending_order_errors_lock:
+            keep = []
+            for item in self.pending_order_errors:
+                if item.get("created_at", 0) <= cutoff:
+                    expired.append(item.get("data") or {})
+                else:
+                    keep.append(item)
+            self.pending_order_errors = keep
+        for data in expired:
+            data["_cfquant_force_order_error"] = True
+            self.publish_callback_event("trader:on_order_error", data)
+
+    def _enrich_qmt_order_error_fields(self, data):
+        """Fill canonical fields that大QMT only embeds in ``errMsg``.
+
+        The QMT strategy callback is ``orderError_callback(orderArgs, errMsg)``
+        and does not expose the MiniQMT ``XtOrderError`` structure.  In
+        particular, counter errors commonly look like
+        ``[COUNTER] [251005][...][p_stock_code=518880,...]``.  Preserve any
+        native structured fields and only infer missing canonical values.
+        """
+        if not isinstance(data, dict):
+            return data
+        # orderError_callback supplies QMT orderArgs names rather than the
+        # MiniQMT callback names. Preserve and canonicalize them first.
+        if not data.get("account_id") and data.get("accountID"):
+            data["account_id"] = data["accountID"]
+        if not data.get("stock_code") and data.get("orderCode"):
+            code = str(data["orderCode"]).strip().upper()
+            if code.startswith(("SH", "SZ", "BJ")) and "." not in code:
+                code = "%s.%s" % (code[2:], code[:2])
+            data["stock_code"] = code
+        if not data.get("strategy_name") and data.get("strategyName"):
+            data["strategy_name"] = data["strategyName"]
+        message = data.get("error_msg") or data.get("m_strErrorMsg") or data.get("message") or data.get("msg")
+        if not message:
+            return data
+        message = str(message)
+        if data.get("error_id") in (None, "", 0, "0") and data.get("m_nErrorID") in (None, "", 0, "0") and data.get("error_code") in (None, "", 0, "0"):
+            for token in re.findall(r"\[(\d+)\]", message):
+                try:
+                    error_id = int(token)
+                except (TypeError, ValueError):
+                    continue
+                if error_id:
+                    data["error_id"] = error_id
+                    break
+        if not data.get("stock_code"):
+            match = re.search(r"(?:^|[\[,;\s])p_stock_code\s*=\s*([A-Za-z0-9_.-]+)", message, re.IGNORECASE)
+            if match:
+                data["stock_code"] = match.group(1)
+        internal_strategy = data.get("strategy_name") or data.get("strategyName")
+        context = self._consume_order_error_context(
+            data.get("account_id") or data.get("accountID"),
+            data.get("stock_code") or data.get("orderCode"),
+            internal_strategy,
+        ) if internal_strategy else None
+        if context:
+            data["strategy_name"] = context.get("strategy_name", "")
+            data["m_strStrategyName"] = context.get("strategy_name", "")
+            data["strategyName"] = context.get("strategy_name", "")
+            data["order_remark"] = context.get("order_remark", "")
+            data["m_strRemark"] = context.get("order_remark", "")
+            data["cfquant_order_error_context_consumed"] = True
+        return data
 
     def _accept_order_callback(self, data):
         """Filter a stale partial-fill update emitted after a filled update."""
@@ -974,7 +1096,8 @@ class NormalQmtBridge(TxTradeBridge):
 
     def _callback_object_to_dict(self, obj):
         fields = [
-            "account_id",
+            "account_id",
+            "accountID",
             "account_type",
             "m_strAccountID",
             "m_strAccountId",
@@ -987,6 +1110,7 @@ class NormalQmtBridge(TxTradeBridge):
             "order_source",
             "source",
             "stock_code",
+            "orderCode",
             "code",
             "market",
             "exchange_id",
@@ -1004,6 +1128,12 @@ class NormalQmtBridge(TxTradeBridge):
             "order_remark",
             "remark",
             "strategy_name",
+            "strategyName",
+            "modelPrice",
+            "modelVolume",
+            "opType",
+            "orderType",
+            "prType",
             "trade_id",
             "deal_id",
             "trade_time",

{cfquant-0.2.41 → cfquant-0.2.42}/cfquant/pipe_bridge.py

@@ -74,6 +74,7 @@ class PipeNormalQmtBridge(NormalQmtBridge):
         return self
 
     def close(self):
+        self._flush_pending_order_errors(force=True)
         self.running = False
         self.worker_event.set()
         self._close_quote_subscriptions()

{cfquant-0.2.41 → cfquant-0.2.42}/cfquant/tests/20_/350/201/224/350/260/203/351/227/256/351/242/230/344/277/256/345/244/215/346/265/213/350/257/225.py

@@ -451,6 +451,34 @@ def test_order_error_callback_can_match_lightweight_request_before_passorder_ret
     assert error.error_id == 103
 
 
+def test_qmt_order_error_message_fills_missing_error_id_and_stock_code():
+    class RecordingTx(object):
+        def __init__(self):
+            self.pushes = []
+
+        def push(self, kind, payload, key):
+            self.pushes.append((kind, payload, key))
+
+    bridge = NormalQmtBridge(None, show=False, schedule_timer=False)
+    tx = RecordingTx()
+    bridge.tx = tx
+    try:
+        bridge.publish_callback_event("trader:on_order_error", {
+            "m_strAccountID": "A123",
+            "m_nAccountType": 2,
+            "order_source": "other",
+            "m_strErrorMsg": "[COUNTER] [251005][证券可用数量不足][p_stock_code=518880,p_enable_amount=0]",
+        })
+    finally:
+        bridge.close()
+
+    payload = json.loads([item for item in tx.pushes if item[0] == "event"][-1][1])
+    data = payload["data"]
+    assert data["error_id"] == 251005
+    assert data["stock_code"] == "518880"
+    assert XtOrderError.from_any(data).error_id == 251005
+
+
 @pytest.mark.parametrize("bridge_class", [NormalQmtBridge, PipeNormalQmtBridge])
 def test_cancel_error_callback_restores_context_by_order_id(bridge_class):
     class RecordingTx(object):

{cfquant-0.2.41 → cfquant-0.2.42}/cfquant/tx_trade_bridge.py

@@ -3,8 +3,9 @@ import os
 import inspect
 import json
 import sys
-import threading
-import time
+import threading
+import time
+import uuid
 
 from .protocol import loads_message, pack_event, pack_response
 from .batch_orders import (
@@ -42,53 +43,53 @@ _LOADED_SOURCE_SHA256 = source_sha256(__file__)
 # bridge against the same ContextInfo. QMT treats every
 # set_auto_trade_callback(True) call as a new registration, so keep the
 # registration state shared across bridge instances.
-_AUTO_TRADE_CALLBACK_LOCK = threading.RLock()
-_AUTO_TRADE_CALLBACK_REGISTRY = {}
-
-# A normal bridge and a trade bridge can be created for the same QMT context.
-# Keep a small relay registry so a stock-order callback received by either
-# entry point can wake the synchronous order resolver immediately.
-_SYNC_ORDER_CALLBACK_RELAY_LOCK = threading.RLock()
-_SYNC_ORDER_CALLBACK_RELAYS = {}
-
-
-def _register_sync_order_callback_relay(bridge):
-    context = getattr(bridge, "context", None)
-    if context is None:
-        return
-    key = id(context)
-    with _SYNC_ORDER_CALLBACK_RELAY_LOCK:
-        bucket = _SYNC_ORDER_CALLBACK_RELAYS.setdefault(key, [])
-        if bridge not in bucket:
-            bucket.append(bridge)
-
-
-def _unregister_sync_order_callback_relay(bridge):
-    context = getattr(bridge, "context", None)
-    if context is None:
-        return
-    key = id(context)
-    with _SYNC_ORDER_CALLBACK_RELAY_LOCK:
-        bucket = _SYNC_ORDER_CALLBACK_RELAYS.get(key, [])
-        bucket[:] = [item for item in bucket if item is not bridge]
-        if not bucket:
-            _SYNC_ORDER_CALLBACK_RELAYS.pop(key, None)
-
-
-def relay_sync_order_callback(context, order):
-    """Forward a formatted order callback to trade bridges sharing context."""
-    if context is None:
-        return 0
-    with _SYNC_ORDER_CALLBACK_RELAY_LOCK:
-        bridges = list(_SYNC_ORDER_CALLBACK_RELAYS.get(id(context), ()))
-    matched = 0
-    for bridge in bridges:
-        try:
-            if bridge._resolve_pending_sync_order_callback(order):
-                matched += 1
-        except Exception:
-            continue
-    return matched
+_AUTO_TRADE_CALLBACK_LOCK = threading.RLock()
+_AUTO_TRADE_CALLBACK_REGISTRY = {}
+
+# A normal bridge and a trade bridge can be created for the same QMT context.
+# Keep a small relay registry so a stock-order callback received by either
+# entry point can wake the synchronous order resolver immediately.
+_SYNC_ORDER_CALLBACK_RELAY_LOCK = threading.RLock()
+_SYNC_ORDER_CALLBACK_RELAYS = {}
+
+
+def _register_sync_order_callback_relay(bridge):
+    context = getattr(bridge, "context", None)
+    if context is None:
+        return
+    key = id(context)
+    with _SYNC_ORDER_CALLBACK_RELAY_LOCK:
+        bucket = _SYNC_ORDER_CALLBACK_RELAYS.setdefault(key, [])
+        if bridge not in bucket:
+            bucket.append(bridge)
+
+
+def _unregister_sync_order_callback_relay(bridge):
+    context = getattr(bridge, "context", None)
+    if context is None:
+        return
+    key = id(context)
+    with _SYNC_ORDER_CALLBACK_RELAY_LOCK:
+        bucket = _SYNC_ORDER_CALLBACK_RELAYS.get(key, [])
+        bucket[:] = [item for item in bucket if item is not bridge]
+        if not bucket:
+            _SYNC_ORDER_CALLBACK_RELAYS.pop(key, None)
+
+
+def relay_sync_order_callback(context, order):
+    """Forward a formatted order callback to trade bridges sharing context."""
+    if context is None:
+        return 0
+    with _SYNC_ORDER_CALLBACK_RELAY_LOCK:
+        bridges = list(_SYNC_ORDER_CALLBACK_RELAYS.get(id(context), ()))
+    matched = 0
+    for bridge in bridges:
+        try:
+            if bridge._resolve_pending_sync_order_callback(order):
+                matched += 1
+        except Exception:
+            continue
+    return matched
 
 
 XTTRADER_COMPAT_CANDIDATES = {
@@ -237,22 +238,24 @@ class TxTradeBridge(object):
         self.pending_async_orders_lock = threading.RLock()
         self.pending_sync_orders = []
         self.pending_sync_orders_lock = threading.RLock()
-        self.order_request_metadata = {}
-        self.order_request_metadata_lock = threading.RLock()
+        self.order_request_metadata = {}
+        self.order_request_metadata_lock = threading.RLock()
+        self.order_error_contexts = {}
+        self.order_error_contexts_lock = threading.RLock()
         self.order_meta_enabled = bool(order_meta_enabled)
         self.order_meta_cache = order_meta.OrderMetaCache(self.bridge_id)
         self.order_meta_store_lock = threading.RLock()
         self.order_meta_store_initialized = set()
 
-    def set_context(self, context):
-        if self.context is not None and self.context is not context:
-            self._release_auto_trade_callback(self.context)
-            _unregister_sync_order_callback_relay(self)
-        self.context = context
+    def set_context(self, context):
+        if self.context is not None and self.context is not context:
+            self._release_auto_trade_callback(self.context)
+            _unregister_sync_order_callback_relay(self)
+        self.context = context
         if self.account_id:
             self._set_context_account(self.account_id, self.account_type)
-        self._enable_auto_trade_callback()
-        _register_sync_order_callback_relay(self)
+        self._enable_auto_trade_callback()
+        _register_sync_order_callback_relay(self)
         self._log("tx trade bridge context ready")
         self._publish_runtime_report("context_ready")
 
@@ -273,10 +276,10 @@ class TxTradeBridge(object):
         self._publish_runtime_report("start")
         return self
 
-    def close(self):
-        self.running = False
-        self._release_auto_trade_callback()
-        _unregister_sync_order_callback_relay(self)
+    def close(self):
+        self.running = False
+        self._release_auto_trade_callback()
+        _unregister_sync_order_callback_relay(self)
         tx = self.tx
         self.tx = None
         if tx is not None:
@@ -981,7 +984,13 @@ class TxTradeBridge(object):
             ("order_remark", "remark", "strategy_name"),
             msg.get("id", "tx_order"),
         )
-        strategy_name = params.get("strategy_name", "")
+        strategy_name = params.get("strategy_name", "")
+        qmt_strategy_name = self._register_order_error_context(
+            account_id,
+            params.get("stock_code", params.get("code", "")),
+            strategy_name,
+            order_remark,
+        )
         order_meta_record = None
         if self.order_meta_enabled:
             order_meta_record = self._build_order_meta_record(
@@ -1025,12 +1034,13 @@ class TxTradeBridge(object):
                 price_type,
                 params.get("price", 0),
                 params.get("order_volume", params.get("num", 0)),
-                params.get("strategy_name", "1"),
+                qmt_strategy_name,
                 params.get("quick_trade", 2),
                 order_remark,
                 self.context,
             )
-        except Exception as e:
+        except Exception as e:
+            self._discard_order_error_context(account_id, params.get("stock_code", params.get("code", "")), qmt_strategy_name)
             if pending_sync_order is not None:
                 self._discard_pending_sync_order(pending_sync_order)
             if order_meta_record is not None:
@@ -1110,7 +1120,45 @@ class TxTradeBridge(object):
             "previous_order_id": previous_order_id,
         }
 
-    def _register_pending_sync_order(
+    @staticmethod
+    def _order_error_code(stock_code):
+        text = str(stock_code or "").strip().upper()
+        if text.startswith(("SH", "SZ", "BJ")) and "." not in text and len(text) > 2:
+            text = text[2:]
+        return text.split(".", 1)[0]
+
+    def _register_order_error_context(self, account_id, stock_code, strategy_name, order_remark):
+        original = str(strategy_name or "")
+        internal = "%s&&&_cfq_%s" % (original, uuid.uuid4().hex[:12]) if original else "cfq_%s" % uuid.uuid4().hex[:12]
+        key = (str(account_id or "").strip(), self._order_error_code(stock_code), internal)
+        now = time.time()
+        with self.order_error_contexts_lock:
+            cutoff = now - 300.0
+            self.order_error_contexts = {
+                item_key: item for item_key, item in self.order_error_contexts.items()
+                if item.get("created_at", now) >= cutoff
+            }
+            self.order_error_contexts[key] = {
+                "account_id": key[0], "stock_code": key[1],
+                "internal_strategy_name": internal, "strategy_name": original,
+                "order_remark": str(order_remark or ""), "created_at": now,
+                "lifecycle": "pending",
+            }
+            while len(self.order_error_contexts) > 4096:
+                self.order_error_contexts.pop(next(iter(self.order_error_contexts)))
+        return internal
+
+    def _discard_order_error_context(self, account_id, stock_code, internal_strategy):
+        key = (str(account_id or "").strip(), self._order_error_code(stock_code), str(internal_strategy or ""))
+        with self.order_error_contexts_lock:
+            self.order_error_contexts.pop(key, None)
+
+    def _consume_order_error_context(self, account_id, stock_code, internal_strategy):
+        key = (str(account_id or "").strip(), self._order_error_code(stock_code), str(internal_strategy or ""))
+        with self.order_error_contexts_lock:
+            return self.order_error_contexts.pop(key, None)
+
+    def _register_pending_sync_order(
         self,
         account_id,
         account_type,
@@ -1129,18 +1177,18 @@ class TxTradeBridge(object):
             "created_at": time.time(),
             "event": threading.Event(),
         }
-        with self.pending_sync_orders_lock:
-            self.pending_sync_orders.append(record)
-        _register_sync_order_callback_relay(self)
-        return record
+        with self.pending_sync_orders_lock:
+            self.pending_sync_orders.append(record)
+        _register_sync_order_callback_relay(self)
+        return record
 
     def _discard_pending_sync_order(self, record):
         if record is None:
             return
-        with self.pending_sync_orders_lock:
-            self.pending_sync_orders[:] = [
-                item for item in self.pending_sync_orders if item is not record
-            ]
+        with self.pending_sync_orders_lock:
+            self.pending_sync_orders[:] = [
+                item for item in self.pending_sync_orders if item is not record
+            ]
 
     def _resolve_pending_sync_order_callback(self, order):
         """Wake a synchronous resolver when QMT publishes the matching order.
@@ -1175,21 +1223,21 @@ class TxTradeBridge(object):
                 expected_strategy = str(record.get("strategy_name") or "")
                 if not order_remark and strategy_name and expected_strategy and strategy_name != expected_strategy:
                     continue
-                if self._is_previous_order_detail(order, record.get("previous_order_id")):
-                    continue
-                # Some QMT builds include the internal reference directly in
-                # the callback.  Keep it so the synchronous path can return
-                # without a full ORDER-history query.
-                callback_order_id = None
-                for name in ("m_nRef", "m_nOrderID", "order_id"):
-                    callback_order_id = self._normalize_order_id(self._get_value(order, name))
-                    if callback_order_id is not None:
-                        break
-                previous_key = self._order_reference_key(record.get("previous_order_id"))
-                if callback_order_id is not None and self._order_reference_key(callback_order_id) != previous_key:
-                    record["callback_order_id"] = callback_order_id
-                if order_sysid not in (None, ""):
-                    record["callback_order_sysid"] = str(order_sysid)
+                if self._is_previous_order_detail(order, record.get("previous_order_id")):
+                    continue
+                # Some QMT builds include the internal reference directly in
+                # the callback.  Keep it so the synchronous path can return
+                # without a full ORDER-history query.
+                callback_order_id = None
+                for name in ("m_nRef", "m_nOrderID", "order_id"):
+                    callback_order_id = self._normalize_order_id(self._get_value(order, name))
+                    if callback_order_id is not None:
+                        break
+                previous_key = self._order_reference_key(record.get("previous_order_id"))
+                if callback_order_id is not None and self._order_reference_key(callback_order_id) != previous_key:
+                    record["callback_order_id"] = callback_order_id
+                if order_sysid not in (None, ""):
+                    record["callback_order_sysid"] = str(order_sysid)
                 record["callback_seen_at"] = time.time()
                 record["event"].set()
                 return True
@@ -1218,27 +1266,27 @@ class TxTradeBridge(object):
             wait_seconds = max(0.0, float(wait_seconds or 0))
         except Exception:
             wait_seconds = 2.0
-        deadline = time.time() + wait_seconds
-        while True:
-            if pending_sync_order is not None:
-                callback_order_id = pending_sync_order.get("callback_order_id")
-                if callback_order_id is not None:
-                    return callback_order_id
-            # A callback is the cheap readiness signal.  Waiting for it before
-            # querying the complete ORDER list avoids repeatedly transferring
-            # multi-megabyte histories through QMT while the new order is still
-            # being committed.  A zero wait keeps the one-shot lookup behavior
-            # used by callers that explicitly disable waiting.
-            if (
-                pending_sync_order is not None
-                and wait_seconds > 0
-                and not pending_sync_order.get("callback_seen_at")
-                and time.time() < deadline
-            ):
-                pending_sync_order["event"].wait(min(0.05, max(0.0, deadline - time.time())))
-                pending_sync_order["event"].clear()
-                continue
-            try:
+        deadline = time.time() + wait_seconds
+        while True:
+            if pending_sync_order is not None:
+                callback_order_id = pending_sync_order.get("callback_order_id")
+                if callback_order_id is not None:
+                    return callback_order_id
+            # A callback is the cheap readiness signal.  Waiting for it before
+            # querying the complete ORDER list avoids repeatedly transferring
+            # multi-megabyte histories through QMT while the new order is still
+            # being committed.  A zero wait keeps the one-shot lookup behavior
+            # used by callers that explicitly disable waiting.
+            if (
+                pending_sync_order is not None
+                and wait_seconds > 0
+                and not pending_sync_order.get("callback_seen_at")
+                and time.time() < deadline
+            ):
+                pending_sync_order["event"].wait(min(0.05, max(0.0, deadline - time.time())))
+                pending_sync_order["event"].clear()
+                continue
+            try:
                 orders = self._query_trade_detail({
                     "account": {"account_id": account_id, "account_type": account_type},
                 }, "order")
@@ -1295,8 +1343,8 @@ class TxTradeBridge(object):
             # returned by order queries/callbacks. Wait for the matching detail.
             if time.time() >= deadline:
                 return None
-            if pending_sync_order is not None:
-                pending_sync_order["event"].wait(min(0.05, max(0.0, deadline - time.time())))
+            if pending_sync_order is not None:
+                pending_sync_order["event"].wait(min(0.05, max(0.0, deadline - time.time())))
                 pending_sync_order["event"].clear()
             else:
                 time.sleep(0.05)

{cfquant-0.2.41 → cfquant-0.2.42}/cfquant/version.py

@@ -1,5 +1,5 @@
 # -*- coding: utf-8 -*-
 """cfquant core version metadata."""
 
-__version__ = "0.2.41"
-WEB_VERSION = "web_20260924_02"
+__version__ = "0.2.42"
+WEB_VERSION = "web_20260925_01"

{cfquant-0.2.41 → cfquant-0.2.42}/cfquant/xttype.py

@@ -1209,6 +1209,22 @@ class XtOrderError(DictObject):
         _set_first(data, "strategy_name", ("m_strStrategyName",), default="")
         _set_first(data, "order_remark", ("m_strRemark", "m_strOrderRemark"), default="")
         _normalize_order_id_field(data)
+        # 大 QMT 的 orderError_callback 只提供错误文本，柜台错误码和股票代码
+        # 常以内嵌字段出现，例如 [251005]... [p_stock_code=518880,...]。
+        # 仅在标准字段缺失时补充，保留 MiniQMT 原生字段优先级。
+        if data.get("error_id") in (None, "", 0, "0"):
+            for token in re.findall(r"\[(\d+)\]", str(data.get("error_msg") or "")):
+                if int(token):
+                    data["error_id"] = int(token)
+                    break
+        if not data.get("stock_code"):
+            match = re.search(
+                r"(?:^|[\[,;\s])p_stock_code\s*=\s*([A-Za-z0-9_.-]+)",
+                str(data.get("error_msg") or ""),
+                re.IGNORECASE,
+            )
+            if match:
+                data["stock_code"] = match.group(1)
         if data.get("order_id") in (0, "0", -1, "-1"):
             data["order_id"] = -1
         data["account_id"] = _coerce_text(data.get("account_id"))

{cfquant-0.2.41 → cfquant-0.2.42}/cfquant.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.41
+Version: 0.2.42
 Summary: QMT local bridge and xtquant-compatible Python client.
 License: MIT
 Requires-Python: >=3.8