cfquant 0.2.51__tar.gz → 0.2.52__tar.gz

{cfquant-0.2.51 → cfquant-0.2.52}/PKG-INFO

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

{cfquant-0.2.51 → cfquant-0.2.52}/cfquant/client.py

@@ -7,7 +7,8 @@ import time
 
 from .config import get_config
 from .callback_dispatcher import CallbackDispatcher, dispatch_callbacks
-from .protocol import decode_value, dumps_message, loads_message, new_id, pack_request
+from .protocol import decode_value, dumps_message, loads_message, new_id, pack_request
+from .rpc_timing import RpcTiming
 
 
 class CfquantError(RuntimeError):
@@ -155,7 +156,7 @@ class LTtxRpcClient(object):
                         pass
                 self._pending.clear()
 
-    def request(self, action, params=None, timeout=None, request_channel=None):
+    def request(self, action, params=None, timeout=None, request_channel=None, response_meta=None):
         effective_timeout = float(timeout or self.timeout)
         request_id = new_id("req")
         raw = pack_request(
@@ -167,6 +168,7 @@ class LTtxRpcClient(object):
             timeout=effective_timeout,
         )
         q = queue.Queue(maxsize=1)
+        timing = RpcTiming(response_meta, request_id)
         try:
             with self._lock:
                 self.start()
@@ -177,11 +179,13 @@ class LTtxRpcClient(object):
                 msg = q.get(timeout=effective_timeout)
             except queue.Empty:
                 raise CfquantTimeout("cfquant request timeout: %s" % action)
-            if not msg.get("ok"):
+            timing.received(msg)
+            if not msg.get("ok"):
                 err = msg.get("error") or {}
                 raise CfquantError(err.get("message") or str(err))
-            return decode_value(msg.get("result"))
-        finally:
+            return timing.decode(msg.get("result"), decode_value)
+        finally:
+            timing.finish()
             with self._pending_lock:
                 self._pending.pop(request_id, None)
 

{cfquant-0.2.51 → cfquant-0.2.52}/cfquant/level2.py

@@ -1,5 +1,7 @@
 """Level2 data adapters shared by the SDK and QMT bridges."""
 
+from .protocol import dataframe_numeric_rows
+
 L2_PERIODS = (
     "l2quote", "l2quoteaux", "l2order", "l2transaction",
     "l2transactioncount", "l2orderqueue",
@@ -93,7 +95,11 @@ def quote_plain(value):
 
 def quote_records(value):
     if hasattr(value, "columns") and hasattr(value, "to_dict"):
-        # DataFrame.values can round large integer IDs in a mixed float/int table.
+        rows = dataframe_numeric_rows(value)
+        if rows is not None:
+            columns = list(value.columns)
+            return quote_plain([dict(zip(columns, row)) for row in rows])
+        # Keep pandas' scalar boxing for nullable, date-like and object fields.
         return quote_plain(value.to_dict("records"))
     names = getattr(getattr(value, "dtype", None), "names", None)
     if names:

{cfquant-0.2.51 → cfquant-0.2.52}/cfquant/normal_bridge.py

@@ -184,6 +184,7 @@ class NormalQmtBridge(TxTradeBridge):
         msg = loads_message(raw)
         if not msg or msg.get("type") != "request":
             return
+        msg["_received_monotonic"] = time.perf_counter()
         action = msg.get("action")
         if action == "cfquant.ping":
             self._send_response(msg, {"pong": True, "ts": time.time(), "request_channel": self.request_channel})
@@ -840,7 +841,7 @@ class NormalQmtBridge(TxTradeBridge):
         client_id = msg.get("client_id") or msg.get("reply_channel")
         if not client_id:
             return
-        response = pack_response(msg.get("id"), ok=True, result=result)
+        response = pack_response(msg.get("id"), ok=True, result=result, meta=msg.get("_response_meta"))
         self.tx.push("response", response, client_id)
 
     def _send_error(self, msg, error):
@@ -851,7 +852,7 @@ class NormalQmtBridge(TxTradeBridge):
             "normal bridge send_error action=%s id=%s client_id=%s error=%s"
             % (msg.get("action"), msg.get("id"), client_id, error)
         )
-        response = pack_response(msg.get("id"), ok=False, error=error)
+        response = pack_response(msg.get("id"), ok=False, error=error, meta=msg.get("_response_meta"))
         self.tx.push("response", response, client_id)
 
     def publish_callback_event(self, event_name, obj):

{cfquant-0.2.51 → cfquant-0.2.52}/cfquant/pipe_bridge.py

@@ -66,7 +66,9 @@ class PipeNormalQmtBridge(NormalQmtBridge):
             endpoint_name="normal",
             show=self.show,
             connect_timeout_ms=self.connect_timeout_ms,
-        ).start()
+        )
+        self.tx._log = self._log
+        self.tx.start()
         self.tx.start_txg(self.request_channel)
         self.recv_thread = threading.Thread(target=self._recv_loop)
         self.recv_thread.daemon = True
@@ -153,7 +155,9 @@ class PipeTradeBridge(TxTradeBridge):
             endpoint_name="trade",
             show=self.show,
             connect_timeout_ms=self.connect_timeout_ms,
-        ).start()
+        )
+        self.tx._log = self._log
+        self.tx.start()
         self.tx.start_txg(self.request_channel)
         self._log(
             "pipe trade bridge started pipe=%s request_channel=%s"

{cfquant-0.2.51 → cfquant-0.2.52}/cfquant/pipe_client.py

@@ -11,7 +11,8 @@ from .pipe_transport import (
     loads_pipe_message,
     normalize_pipe_name,
 )
-from .protocol import decode_value, dumps_message, loads_message, new_id, pack_request
+from .protocol import decode_value, dumps_message, loads_message, new_id, pack_request
+from .rpc_timing import RpcTiming
 
 
 class PipeRpcClient(object):
@@ -70,7 +71,7 @@ class PipeRpcClient(object):
             self._close_conns_locked()
             self._fail_pending("cfquant pipe client closed")
 
-    def request(self, action, params=None, timeout=None, request_channel=None):
+    def request(self, action, params=None, timeout=None, request_channel=None, response_meta=None):
         effective_timeout = float(timeout or self.timeout)
         request_id = new_id("req")
         raw = pack_request(
@@ -82,6 +83,7 @@ class PipeRpcClient(object):
             timeout=effective_timeout,
         )
         q = queue.Queue(maxsize=1)
+        timing = RpcTiming(response_meta, request_id)
         try:
             with self._lock:
                 self.start()
@@ -98,13 +100,15 @@ class PipeRpcClient(object):
                 from .client import CfquantTimeout
 
                 raise CfquantTimeout("cfquant pipe request timeout: %s" % action)
-            if not msg.get("ok"):
+            timing.received(msg)
+            if not msg.get("ok"):
                 err = msg.get("error") or {}
                 from .client import CfquantError
 
                 raise CfquantError(err.get("message") or str(err))
-            return decode_value(msg.get("result"))
-        finally:
+            return timing.decode(msg.get("result"), decode_value)
+        finally:
+            timing.finish()
             with self._pending_lock:
                 self._pending.pop(request_id, None)
 

{cfquant-0.2.51 → cfquant-0.2.52}/cfquant/protocol.py

@@ -80,8 +80,8 @@ def loads_message(raw):
         raw = raw.decode("utf-8", errors="replace")
     if not isinstance(raw, str):
         return None
-    if "|" in raw:
-        _, raw = raw.split("|", 1)
+    if not raw.startswith(MESSAGE_PREFIX) and "|" in raw:
+        _, raw = raw.split("|", 1)
     if not raw.startswith(MESSAGE_PREFIX):
         return None
     try:
@@ -107,14 +107,20 @@ def pack_request(action, params=None, reply_channel=None, client_id=None, reques
     return dumps_message(payload)
 
 
-def pack_response(request_id, ok=True, result=None, error=None, meta=None):
-    return dumps_message({
+def pack_response(request_id, ok=True, result=None, error=None, meta=None):
+    started = time.perf_counter()
+    encoded = encode_value(result)
+    meta = dict(meta or {})
+    timing = meta.get("timing")
+    if isinstance(timing, dict) and isinstance(timing.get("qmt"), dict):
+        timing["qmt"]["encode_ms"] = round((time.perf_counter() - started) * 1000, 3)
+    return dumps_message({
         "type": "response",
         "id": request_id,
         "ok": bool(ok),
-        "result": encode_value(result),
+        "result": encoded,
         "error": encode_error(error),
-        "meta": meta or {},
+        "meta": meta,
     })
 
 
@@ -212,25 +218,60 @@ def _looks_like_series(value):
     )
 
 
-def _clean_cell(value):
+def _clean_cell(value):
     if value is None:
         return None
     if isinstance(value, float) and (math.isnan(value) or math.isinf(value)):
         return None
-    return encode_value(value)
-
-
+    return encode_value(value)
+
+
+def dataframe_numeric_rows(value):
+    """Bulk rows for plain numeric frames; None keeps pandas' other semantics."""
+    columns = getattr(value, "columns", None)
+    dtypes = getattr(value, "dtypes", None)
+    if columns is None or not len(columns) or dtypes is None or not getattr(columns, "is_unique", False):
+        return None
+    # Nullable, object and date-like columns need pandas' scalar boxing rules.
+    # Restrict this fast path so callers keep their existing null/date behavior.
+    for dtype in dtypes:
+        if (type(dtype).__module__.split(".", 1)[0] != "numpy"
+                or dtype.kind not in ("b", "i", "u", "f") or dtype.itemsize > 8):
+            return None
+    # Combining mixed numeric blocks before this cast can round large IDs.
+    return value.astype(object, copy=False).values.tolist()
+
+
 def _encode_dataframe(value):
     try:
-        raw_rows = list(value.itertuples(index=False, name=None))
+        # itertuples builds a Series per column, which is expensive for QMT's
+        # stock-by-date history frames. Cast BEFORE combining the blocks: using
+        # values directly can round int64/uint64 IDs in mixed float/int frames.
+        # astype also works with QMT's pandas 0.22 (which has no to_numpy).
+        raw_rows = value.astype(object, copy=False).values.tolist() if len(value.columns) else []
     except Exception:
         try:
-            raw_rows = value.values.tolist()
+            raw_rows = list(value.itertuples(index=False, name=None))
         except Exception:
-            raw_rows = []
-    rows = []
-    for row in raw_rows:
-        rows.append([_clean_cell(v) for v in row])
+            try:
+                raw_rows = value.values.tolist()
+            except Exception:
+                raw_rows = []
+    rows = []
+    for row in raw_rows:
+        rows.append([_clean_cell(v) for v in row])
+    # Thousands of date columns usually share one dtype. Formatting its name
+    # repeatedly can cost more than extracting the actual values.
+    dtype_flags = {}
+    object_columns = []
+    for name, dtype in getattr(value, "dtypes", {}).items():
+        is_object = dtype_flags.get(dtype)
+        if is_object is None:
+            dtype_name = str(dtype)
+            is_object = dtype_name == "object" or dtype_name.startswith(("Int", "UInt"))
+            dtype_flags[dtype] = is_object
+        if is_object:
+            object_columns.append(_encode_label(name))
     index_name = getattr(getattr(value, "index", None), "name", None)
     return {
         "__cf_type__": "dataframe",
@@ -238,8 +279,7 @@ def _encode_dataframe(value):
         "index": [_encode_label(i) for i in getattr(value, "index", [])],
         "data": rows,
         "index_name": _encode_label(index_name) if index_name is not None else None,
-        "object_columns": [_encode_label(name) for name, dtype in getattr(value, "dtypes", {}).items()
-                           if str(dtype) == "object" or str(dtype).startswith(("Int", "UInt"))],
+        "object_columns": object_columns,
     }
 
 
@@ -328,6 +368,13 @@ def decode_value(value):
                     parts[2] = tuple(parts[2])
                 dtype_descr.append(tuple(parts))
             dtype = np.dtype(dtype_descr)
+            # JSON turns each structured record tuple into a list. NumPy
+            # treats that list as another array dimension unless restored.
+            def record_tuples(items, dimensions):
+                if dimensions == 0:
+                    return tuple(items)
+                return [record_tuples(item, dimensions - 1) for item in items]
+            data = record_tuples(data, len(value.get("shape", [len(data)])))
         elif value.get("dtype"):
             try:
                 dtype = np.dtype(value.get("dtype"))

cfquant-0.2.52/cfquant/qmt_binding_settings.py

@@ -0,0 +1,39 @@
+"""Persisted per-binding QMT scheduling and log preferences."""
+DEFAULT_TIMER_INTERVAL_MS = 1
+MIN_TIMER_INTERVAL_MS = 1
+MAX_TIMER_INTERVAL_MS = 1000
+
+
+def normalize_qmt_runtime_settings(value=None, existing=None, strict=False):
+    if value is not None and not isinstance(value, dict):
+        if strict:
+            raise ValueError("QMT runtime settings must be an object")
+        value = None
+    data = dict(existing or {})
+    data.update(value or {})
+    interval = data.get("timer_interval_ms", DEFAULT_TIMER_INTERVAL_MS)
+    try:
+        if isinstance(interval, bool) or str(interval).strip() != str(int(interval)):
+            raise ValueError()
+        interval = int(interval)
+        if not MIN_TIMER_INTERVAL_MS <= interval <= MAX_TIMER_INTERVAL_MS:
+            raise ValueError()
+    except (TypeError, ValueError, OverflowError):
+        if strict:
+            raise ValueError("QMT 调度间隔必须是 1–1000 ms 的整数")
+        interval = DEFAULT_TIMER_INTERVAL_MS
+    enabled = data.get("log_enabled")  # None preserves legacy global preferences.
+    if enabled is not None and not isinstance(enabled, bool):
+        if strict:
+            raise ValueError("QMT 日志设置必须为 true、false 或 null（跟随全局）")
+        enabled = None
+    return {"timer_interval_ms": interval, "log_enabled": enabled}
+
+
+def qmt_runtime_identity(row, global_log_enabled=True):
+    settings = normalize_qmt_runtime_settings((row or {}).get("qmt_runtime"))
+    enabled = settings["log_enabled"]
+    if (row or {}).get("mode") == "lttx":
+        enabled = None  # Advanced entries keep their existing global controls.
+    return {"qmt_timer_interval_ms": settings["timer_interval_ms"],
+            "qmt_log_enabled": bool(global_log_enabled) if enabled is None else enabled}

cfquant-0.2.52/cfquant/rpc_timing.py

@@ -0,0 +1,45 @@
+"""Per-request diagnostics; never change the RPC method's return value."""
+import time
+
+
+class RpcTiming(object):
+    def __init__(self, output, request_id):
+        self.output = output
+        self.started = time.perf_counter()
+        self.received_at = None
+        if output is not None:
+            output.update({
+                "request_id": request_id,
+                "qmt": {"available": False, "reason": "no_response"},
+                "rpc": {"response_received": False},
+            })
+
+    def received(self, message):
+        self.received_at = time.perf_counter()
+        if self.output is None:
+            return
+        self.output["rpc"].update({
+            "response_received": True,
+            "response_ok": bool(message.get("ok")),
+            "wait_ms": round((self.received_at - self.started) * 1000, 3),
+        })
+        meta = message.get("meta") or {}
+        qmt = (meta.get("timing") or {}).get("qmt")
+        self.output["qmt"] = dict(qmt) if isinstance(qmt, dict) else {
+            "available": False, "reason": "bridge_timing_unavailable",
+        }
+
+    def decode(self, value, decoder):
+        started = time.perf_counter()
+        try:
+            return decoder(value)
+        finally:
+            if self.output is not None:
+                self.output["rpc"]["decode_ms"] = round((time.perf_counter() - started) * 1000, 3)
+
+    def finish(self):
+        if self.output is not None:
+            elapsed = round((time.perf_counter() - self.started) * 1000, 3)
+            self.output["rpc"]["total_ms"] = elapsed
+            if self.received_at is None:
+                self.output["rpc"]["wait_ms"] = elapsed

{cfquant-0.2.51 → cfquant-0.2.52}/cfquant/tests/28_Level2/346/216/245/345/217/243/351/200/202/351/205/215/346/265/213/350/257/225.py

@@ -32,7 +32,8 @@ CODE = "000001.SZ"
 def lite_namespace(path):
     tree = ast.parse(path.read_text(encoding="gbk"))
     helpers = {key for key in vars(level2) if not key.startswith("__") and key != "l2_array"}
-    functions = {"encode_value", "_encode_dataframe", "_encode_series", "_clean_cell", "_looks_like_dataframe", "_looks_like_series", "_get_pandas"}
+    functions = {"encode_value", "_encode_dataframe", "_encode_series", "_encode_label", "_encode_ndarray",
+                 "_clean_cell", "_looks_like_dataframe", "_looks_like_series", "_get_pandas"}
     body = []
     for node in tree.body:
         if isinstance(node, ast.FunctionDef) and node.name in helpers | functions:
@@ -143,7 +144,8 @@ def test_sdk_l2_queries_preserve_fields_precision_and_depth(monkeypatch, bridge,
 def test_six_period_query_protocol_and_no_forward_fill(bridge, period):
     result = rpc(bridge, "xtdata.get_market_data_ex", {"stock_list": [CODE], "period": period, "fill_data": True})
     assert result[CODE]["orderNo"].iloc[0] == BIG_ID
-    assert result[CODE]["bidPrice"].iloc[0] == [11.6, 11.5]
+    assert isinstance(result[CODE]["bidPrice"].iloc[0], np.ndarray)
+    np.testing.assert_array_equal(result[CODE]["bidPrice"].iloc[0], [11.6, 11.5])
     assert bridge.context.calls[-1][2] == period
     assert bridge.context.calls[-1][-1] is False
     rpc(bridge, "xtdata.get_market_data", {"stock_list": [CODE], "period": period})
@@ -254,7 +256,8 @@ def test_wire_encoder_preserves_nullable_ids_arrays_and_numpy_scalars(path):
     result = decode_value(json.loads(json.dumps(encoder(frame))))
     assert result["id"].iloc[0] == BIG_ID
     assert result["id"].iloc[1] is None
-    assert result["depth"].iloc[0] == [100, 200]
+    assert isinstance(result["depth"].iloc[0], np.ndarray)
+    np.testing.assert_array_equal(result["depth"].iloc[0], [100, 200])
     assert encoder(np.uint64(2 ** 64 - 1)) == 2 ** 64 - 1
 
 

{cfquant-0.2.51 → cfquant-0.2.52}/cfquant/tests/test_api_tester_browser.py

@@ -16,8 +16,8 @@ def open_test(page, frontend_url, entry):
     requests, errors = open_app(page, frontend_url)
     page.locator('#setupOverlay [data-open-tutorial]').click()
     page.evaluate('(id) => window.CfquantPythonReference.open(id)', entry)
-    page.locator('[data-python-test]').click()
-    panel = page.locator('.api-inline-test:not([hidden])')
+    page.locator('#tutorialReader [data-python-test]').click()
+    panel = page.locator('#tutorialReader .api-inline-test:not([hidden])')
     expect(panel).to_be_visible()
     assert all(method == 'GET' for method, path in requests)
     return panel, requests, errors
@@ -36,7 +36,7 @@ def test_tutorial_query_results_copy_reset_and_error(page, frontend_url):
     def reply(route):
         sent.append(route.request.post_data_json)
         route.fulfill(json={'ok': True, 'data': {'result': {'000001.SZ': {'lastPrice': 11.7}}, 'latency_ms': 12.5}})
-    page.route('**/api/data/full-tick', reply)
+    page.route('**/api/python/xtdata', reply)
     panel.locator('[name="code_list"]').fill('000001.SZ')
     panel.locator('[type="submit"]').click()
     expect(panel.locator('[data-test-status]')).to_have_text('请求完成')
@@ -51,7 +51,7 @@ def test_tutorial_query_results_copy_reset_and_error(page, frontend_url):
     expect(panel.locator('[data-test-output]')).to_have_text('')
     panel.locator('[data-test-reset]').click()
     expect(panel.locator('[name="code_list"]')).to_have_value('000001.SZ,600000.SH')
-    page.route('**/api/data/full-tick', lambda route: route.fulfill(status=401, json={'ok': False, 'error': 'invalid credentials'}))
+    page.route('**/api/python/xtdata', lambda route: route.fulfill(status=401, json={'ok': False, 'error': 'invalid credentials'}))
     panel.locator('[type="submit"]').click()
     expect(panel.locator('[data-test-status]')).to_have_text('请求失败')
     expect(panel.locator('[data-test-output]')).to_contain_text('invalid credentials')
@@ -72,7 +72,7 @@ def test_inline_api_tester_prefers_api_key_when_web_auth_enabled(page, frontend_
         sent_headers.append(route.request.headers)
         route.fulfill(json={'ok': True, 'data': {'result': {'000001.SZ': {'lastPrice': 11.7}}}})
 
-    page.route('**/api/data/full-tick', reply)
+    page.route('**/api/python/xtdata', reply)
     panel.locator('[name="code_list"]').fill('000001.SZ')
     panel.locator('[type="submit"]').click()
     expect(panel.locator('[data-test-output]')).to_contain_text('lastPrice')
@@ -179,8 +179,8 @@ def test_stop_waiting_does_not_resubmit_and_result_survives_navigation(page, fro
     pending[0].abort()
     page.evaluate("window.CfquantPythonReference.open('xtdata.get_full_tick')")
     page.evaluate("window.CfquantPythonReference.open('cftrader.order_stock_batch')")
-    page.locator('[data-python-test]').click()
-    expect(page.locator('[data-test-output]')).to_contain_text('避免重复提交')
+    page.locator('#tutorialReader [data-python-test]').click()
+    expect(page.locator('#tutorialReader [data-test-output]')).to_contain_text('避免重复提交')
     assert len(pending) == 1
     assert errors == []
 
@@ -197,7 +197,7 @@ def test_callback_view_filters_original_events_and_types_are_not_executable(page
     expect(panel.locator('[data-test-output]')).to_contain_text('1001')
     assert 'event_name=trader%3Aon_stock_order' in pending[0]
     page.evaluate("window.CfquantPythonReference.open('type.XtAsset')")
-    expect(page.locator('[data-python-test]')).to_have_count(0)
+    expect(page.locator('#tutorialReader [data-python-test]')).to_have_count(0)
     assert errors == []
 
 
@@ -207,6 +207,9 @@ def test_main_api_batch_testing_summary_and_clear(page, frontend_url):
     page.mouse.move(page.viewport_size['width'] - 1, page.viewport_size['height'] - 1)
     page.keyboard.press('Escape')
     page.locator('.nav-item[data-view="api"]').click()
+    group = page.locator('.api-group').filter(has=page.locator('[data-endpoint-id="cftrader.order_stock_batch"]'))
+    if group.locator('.api-group-head').get_attribute('aria-expanded') != 'true':
+        group.locator('.api-group-head').click()
     page.locator('[data-endpoint-id="cftrader.order_stock_batch"]').click()
     sent = []
 
@@ -234,3 +237,95 @@ def test_main_api_batch_testing_summary_and_clear(page, frontend_url):
     expect(page.locator('#apiResponseBox')).to_have_text('')
     expect(page.locator('#apiResultSummary')).to_have_text('')
     assert errors == []
+
+
+def test_main_market_timing_success_timeout_and_old_bridge(page, frontend_url):
+    requests, errors = open_app(page, frontend_url, setup_required=False)
+    page.locator('#closeOnboardingBtn').click()
+    page.mouse.move(page.viewport_size['width'] - 1, page.viewport_size['height'] - 1)
+    page.keyboard.press('Escape')
+    page.locator('.nav-item[data-view="api"]').click()
+    page.locator('[data-api-group="data"]').click()
+    page.locator('[data-endpoint-id="full_tick"]').click()
+    replies = [{
+        'ok': True, 'data': {'latency_ms': 500, 'result': {'000001.SZ': {'lastPrice': 11.3}},
+        'timing': {'qmt': {'available': True, 'queue_ms': 400, 'native_ms': 70,
+                          'convert_ms': 5, 'encode_ms': 4, 'fallback_used': True},
+                   'rpc': {'wait_ms': 495, 'decode_ms': 2}, 'web': {'result_convert_ms': 3}}}},
+        {'ok': False, 'error': 'cfquant pipe request timeout', 'status': 400,
+         'timing': {'qmt': {'available': False, 'reason': 'no_response'}, 'rpc': {'wait_ms': 12000}}},
+        {'ok': True, 'data': {'latency_ms': 80, 'result': {},
+         'timing': {'qmt': {'available': False, 'reason': 'bridge_timing_unavailable'}}}},
+    ]
+    page.route('**/api/data/full-tick', lambda route: route.fulfill(json=replies.pop(0)))
+    form = page.locator('#apiForm')
+    form.locator('[type="submit"]').click()
+    timing = page.locator('#apiResponseLatencyMeta')
+    expect(timing).to_contain_text('QMT 原生取数 70.0 ms')
+    expect(timing).to_contain_text('兼容格式转换 5.00 ms')
+    expect(timing).to_contain_text('Web 结果转换 3.00 ms')
+    expect(timing).to_contain_text('旧行情接口已回退到扩展接口')
+    assert page.locator('.api-workbench').evaluate('node => node.scrollWidth <= node.clientWidth')
+    page.locator('#apiResponseLatency').scroll_into_view_if_needed()
+    screenshot(page, 'market-timing')
+    form.locator('[type="submit"]').click()
+    expect(timing).to_contain_text('QMT 耗时未取得（未收到回包）')
+    expect(timing).not_to_contain_text('QMT 原生取数')
+    form.locator('[type="submit"]').click()
+    expect(timing).to_contain_text('QMT 耗时未取得（桥接脚本未提供）')
+    assert errors == []
+
+
+def test_market_ex_switch_keeps_query_and_displays_response_timing(page, frontend_url):
+    requests, errors = open_app(page, frontend_url, setup_required=False)
+    page.locator('#closeOnboardingBtn').click()
+    page.mouse.move(page.viewport_size['width'] - 1, page.viewport_size['height'] - 1)
+    page.keyboard.press('Escape')
+    page.locator('.nav-item[data-view="api"]').click()
+    page.locator('[data-api-group="data"]').click()
+    entry = page.locator('[data-endpoint-id="market_data_ex"]')
+    expect(entry).to_contain_text('get_market_data_ex')
+    page.locator('[data-endpoint-id="market_data"]').click()
+    form = page.locator('#apiForm')
+    fields = {'field_list': 'open,close,volume', 'stock_list': '000001.SZ,600000.SH',
+              'start_time': '20260101', 'end_time': '20261014', 'count': '20', 'timeout': '15'}
+    for name, value in fields.items():
+        form.locator('[name="%s"]' % name).fill(value)
+    form.locator('[name="period"]').fill('1d')
+    form.locator('[name="fill_data"]').fill('0')
+    page.locator('#apiResponseBox').evaluate("node => node.textContent = 'old response'")
+    before = page.evaluate('currentApiRequest().body')
+    form.locator('[data-market-variant="market_data_ex"]').click()
+    expect(page.locator('#apiTitle')).to_contain_text('get_market_data_ex')
+    expect(page.locator('#apiRoute')).to_have_text('POST /api/data/market-ex')
+    expect(page.locator('#apiResponseBox')).to_have_text('')
+    assert page.evaluate('currentApiRequest().body') == before
+    pending = []
+    page.route('**/api/data/market-ex', lambda route: pending.append(route))
+    form.locator('[type="submit"]').click()
+    expect(form.locator('[type="submit"]')).to_be_disabled()
+    expect(form.locator('[data-market-variant]')).to_be_disabled()
+    page.wait_for_function("state.apiDebugBusy")
+    assert len(pending) == 1
+    assert pending[0].request.post_data_json == before
+    assert before['stock_list'] == ['000001.SZ', '600000.SH']
+    assert before['field_list'] == ['open', 'close', 'volume']
+    assert before['count'] == 20 and before['fill_data'] is False
+    pending[0].fulfill(json={'ok': True, 'data': {'latency_ms': 85, 'result': {
+        '000001.SZ': {'20261014': {'open': 11.0, 'close': 11.5, 'volume': 120000}}},
+        'timing': {'qmt': {'available': True, 'queue_ms': 20, 'native_ms': 5,
+                          'convert_ms': 0, 'encode_ms': 3, 'fallback_used': False},
+                   'rpc': {'wait_ms': 80, 'decode_ms': 2}, 'web': {'result_convert_ms': 1}}}})
+    expect(page.locator('#apiResponseBox')).to_contain_text('120000')
+    expect(page.locator('#apiResponseLatencyMeta')).to_contain_text('QMT 原生取数 5.00 ms')
+    expect(page.locator('#apiResponseLatencyMeta')).to_contain_text('QMT 结果编码 3.00 ms')
+    expect(page.locator('#apiResponseLatencyMeta')).not_to_contain_text('旧行情接口已回退')
+    expect(form.locator('[data-market-variant]')).to_be_enabled()
+    assert page.locator('.api-workbench').evaluate('node => node.scrollWidth <= node.clientWidth')
+    assert page.locator('#apiEndpointList').evaluate('node => node.scrollWidth <= node.clientWidth')
+    screenshot(page, 'market-ex')
+    form.locator('[data-market-variant="market_data"]').click()
+    expect(page.locator('#apiRoute')).to_have_text('POST /api/data/market')
+    assert page.evaluate('currentApiRequest().body') == before
+    assert all(method == 'GET' for method, path in requests)
+    assert errors == []