cfquant 0.2.48__tar.gz → 0.2.50__tar.gz

{cfquant-0.2.48 → cfquant-0.2.50}/PKG-INFO

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

{cfquant-0.2.48 → cfquant-0.2.50}/cfquant/normal_bridge.py

@@ -893,6 +893,7 @@ class NormalQmtBridge(TxTradeBridge):
             self._resolve_pending_sync_order_callback(data)
             relay_sync_order_callback(self.context, data)
             self._handle_async_order_callback(data)
+            self._remember_order_callback_fields(data)
         payload = {
             "type": "event",
             "event": event_name,

cfquant-0.2.50/cfquant/order_identity.py

@@ -0,0 +1,173 @@
+"""Per-submission QMT remarks, compatible with embedded Python 3.6.
+
+The public remark is user data, never a unique order key. Keep a UUID in the
+native remark so independent QMT processes and restarts can recover both.
+"""
+
+import re
+import threading
+import time
+import uuid
+from collections import OrderedDict
+
+
+_ORDER_REMARK_SUFFIX = re.compile(r"__cfq_([0-9a-f]{32})$")
+
+
+def original_order_remark(value):
+    text = str(value or "")
+    match = _ORDER_REMARK_SUFFIX.search(text)
+    return text[:match.start()] if match else text
+
+
+def is_unique_order_remark(value):
+    return bool(_ORDER_REMARK_SUFFIX.search(str(value or "")))
+
+
+def prepare_order_remark(params, fallback=""):
+    original = next((params[name] for name in ("order_remark", "remark", "strategy_name")
+                     if params.get(name) not in (None, "")), "")
+    original = str(original or "")
+    internal = params.get("cfquant_order_remark")
+    if not (is_unique_order_remark(internal) and
+            original_order_remark(internal) in (original, original or str(fallback or ""))):
+        original = original or str(fallback or "")
+        internal = original + "__cfq_" + uuid.uuid4().hex
+    params["cfquant_order_remark"] = internal
+    return internal
+
+
+def order_remark_key(data):
+    getter = data.get if isinstance(data, dict) else lambda name: getattr(data, name, None)
+    values = [getter(name) for name in (
+        "cfquant_order_remark", "user_order_id", "client_order_id",
+        "order_remark", "m_strRemark", "m_strOrderRemark", "remark",
+    )]
+    for value in values:
+        if is_unique_order_remark(value):
+            return str(value)
+    return next((str(value) for value in values if value not in (None, "")), "")
+
+
+def restore_order_remark(data):
+    if isinstance(data, dict):
+        internal = order_remark_key(data)
+        if is_unique_order_remark(internal):
+            data["cfquant_order_remark"] = internal
+            data["order_remark"] = original_order_remark(internal)
+    return data
+
+
+def order_remark_matches_reference(expected, actual):
+    """Compare remarks only AFTER an order reference has matched.
+
+    Some DEAL reports echo the public remark without our UUID. A different
+    UUID still identifies a different submission, even with the same text.
+    """
+    return (not actual or expected == actual or
+            (is_unique_order_remark(expected) and
+             not is_unique_order_remark(actual) and
+             original_order_remark(expected) == actual))
+
+
+class OrderCallbackCache(object):
+    """Bounded, daily order metadata indexed by separate local/broker IDs."""
+
+    def __init__(self, max_orders=4096):
+        self.max_orders = max_orders
+        self.lock = threading.RLock()
+        self.day = ""
+        self.records = OrderedDict()
+        self.by_ref = {}
+
+    def _identity(self, data, account_type):
+        day = time.strftime("%Y%m%d")
+        if day != self.day:
+            self.records.clear()
+            self.by_ref.clear()
+            self.day = day
+        # Historical query rows must not seed today's broker-ID mapping.
+        for name in ("order_date", "trade_date", "m_strInsertDate", "m_strTradeDate", "m_strTradingDay"):
+            value = str(data.get(name) or "").replace("-", "").replace("/", "")
+            if len(value) == 8 and value.isdigit() and value != day:
+                return None, set()
+        account = str(data.get("account_id") or data.get("m_strAccountID") or "").strip()
+        stock = str(data.get("stock_code") or data.get("m_strInstrumentID") or "").strip().upper()
+        market = str(data.get("market") or data.get("m_strExchangeID") or "").strip().upper()
+        if "." in stock:
+            stock, market = stock.rsplit(".", 1)
+        if not account or not stock:
+            return None, set()
+        scope = (account_type, account, stock, market)
+        refs = set()
+        for name in ("order_id", "m_nRef", "m_nOrderID", "m_strOrderRef", "m_strOrderID"):
+            value = str(data.get(name) or "").strip()
+            if value.isdigit() and int(value) > 0:
+                refs.add(("local", str(int(value))))
+        for name in ("order_sysid", "m_strOrderSysID"):
+            value = str(data.get(name) or "").strip()
+            if value and value not in ("0", "-1"):
+                refs.add(("broker", value))
+        return scope, refs
+
+    def _matches(self, scope, refs, data):
+        groups = [self.by_ref[(scope, ref)] for ref in refs if (scope, ref) in self.by_ref]
+        candidates = set.intersection(*groups) if groups else set()
+        matches = []
+        for key in candidates:
+            record = self.records[key]
+            expected, actual = order_remark_key(record["data"]), order_remark_key(data)
+            if expected and not order_remark_matches_reference(expected, actual):
+                continue
+            local = {ref for ref in refs if ref[0] == "local"}
+            known = {ref for ref in record["refs"] if ref[0] == "local"}
+            if local and known and not local.intersection(known):
+                continue
+            matches.append(key)
+        return matches
+
+    def remember(self, data, account_type):
+        if not (data.get("strategy_name") or data.get("m_strStrategyName") or order_remark_key(data)):
+            return
+        with self.lock:
+            scope, refs = self._identity(data, account_type)
+            if scope is None or not refs:
+                return
+            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]
+            key = (scope, identity)
+            if len(matches) == 1:
+                key = matches[0]
+            record = self.records.get(key, {"data": {}, "refs": set()})
+            record["data"].update({name: value for name, value in data.items() if value not in (None, "")})
+            record["refs"].update(refs)
+            self.records[key] = record
+            self.records.move_to_end(key)
+            for ref in refs:
+                self.by_ref.setdefault((scope, ref), set()).add(key)
+            while len(self.records) > self.max_orders:
+                old_key, old = self.records.popitem(last=False)
+                for ref in old["refs"]:
+                    index = (old_key[0], ref)
+                    self.by_ref[index].discard(old_key)
+                    if not self.by_ref[index]:
+                        del self.by_ref[index]
+
+    def enrich(self, data, account_type):
+        with self.lock:
+            scope, refs = self._identity(data, account_type)
+            matches = self._matches(scope, refs, data) if scope is not None else []
+            if len(matches) != 1:
+                return data
+            saved = self.records[matches[0]]["data"]
+            strategy = saved.get("strategy_name") or saved.get("m_strStrategyName")
+            remark = order_remark_key(saved)
+            for name, value in (("strategy_name", strategy), ("m_strStrategyName", strategy),
+                                ("order_remark", remark), ("m_strRemark", remark), ("m_strOrderRemark", remark)):
+                if value and not data.get(name):
+                    data[name] = value
+            if is_unique_order_remark(remark):
+                data["cfquant_order_remark"] = remark
+        return restore_order_remark(data)

{cfquant-0.2.48 → cfquant-0.2.50}/cfquant/order_meta.py

@@ -13,6 +13,7 @@ import re
 import threading
 from .stock_connect import connect_account_type
 from .order_identity import order_remark_key, restore_order_remark, is_unique_order_remark
+from .order_identity import order_remark_matches_reference
 import time
 
 
@@ -609,7 +610,7 @@ class OrderMetaCache(object):
             for order_ref in order_refs:
                 record = self.by_ref.get(self._ctx(callback_record) + (order_ref,))
                 if record and user_order_id and is_unique_order_remark(user_order_id_from_data(record)):
-                    if user_order_id != 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:
                     confidence = "order_ref"

{cfquant-0.2.48 → cfquant-0.2.50}/cfquant/qmt_strategy_deploy.py

@@ -343,13 +343,23 @@ def managed_source(source_path, identity_path, identity, descriptor):
     for start, end, text in sorted(replacements, reverse=True):
         lines[start:end] = [text]
     lines[0] = "# coding: utf-8\n"
-    source = "".join(lines)
-    ast.parse(source, feature_version=(3, 6))
-    helper = Path(__file__).with_name("qmt_strategy_runtime.py").read_text(encoding="utf-8")
-    generated = ("# coding: utf-8\n" + helper + "\n_cq_descriptor = " + ascii(descriptor)
-            + "\n_cq_guard = _CqStrategyLease(_cq_descriptor).acquire()\n"
-            + "_cq_guard.namespace = globals()\ntry:\n"
-            + "    exec(compile(%s, %s, 'exec'), globals())\n" % (ascii(source), ascii(str(source_path)))
+    source = "".join(lines)
+    ast.parse(source, feature_version=(3, 6))
+    helper = Path(__file__).with_name("qmt_strategy_runtime.py").read_text(encoding="utf-8")
+    source_lines = source.splitlines(keepends=True)
+    # Adjacent literals compile to the same source string, while keeping every
+    # entry line visible in QMT's editor. A single ascii(source) hid thousands
+    # of Lite lines behind the same short lease wrapper as the other modes.
+    embedded = "\n".join("        " + ascii(line) for line in source_lines)
+    header = ("# coding: utf-8\n# cfquant managed strategy\n"
+              + "# Mode: " + ascii(descriptor["mode"]) + "\n"
+              + "# Entry: " + ascii(Path(source_path).name) + "\n"
+              + "# Embedded entry: %d lines, preserved line by line below.\n" % len(source_lines)
+              + "# The lease wrapper is shared by all modes.\n\n")
+    generated = (header + helper + "\n_cq_descriptor = " + ascii(descriptor)
+            + "\n_cq_guard = _CqStrategyLease(_cq_descriptor).acquire()\n"
+            + "_cq_guard.namespace = globals()\ntry:\n"
+            + "    exec(compile((\n%s\n    ), %s, 'exec'), globals())\n" % (embedded, ascii(str(source_path)))
             + "    for _cq_name in ('_cf_bridge', '_normal_bridge', '_trade_bridge'):\n"
             + "        if globals().get(_cq_name) is not None:\n"
             + "            globals()[_cq_name].account_type = %s\n" % ascii(identity["account_type"])
@@ -408,13 +418,17 @@ class QmtStrategyManager:
             job.pop("deploy_retry_count", None)
             job.pop("deploy_retry_after", None)
 
-    def _clear_generation_transition(self, job):
-        changed = False
-        for key in ("control_generation", "accepted_generations"):
-            if key in job:
-                job.pop(key, None)
-                changed = True
-        return changed
+    def _clear_generation_transition(self, job):
+        changed = False
+        for key in ("control_generation", "accepted_generations"):
+            if key in job:
+                job.pop(key, None)
+                changed = True
+        for role in job.get("roles", []):
+            if "reimport_from_generation" in role:
+                role.pop("reimport_from_generation", None)
+                changed = True
+        return changed
 
     def _prepare_generation_transition(self, job, previous=None):
         """Keep old same-name containers valid until the replacement starts."""
@@ -467,19 +481,23 @@ class QmtStrategyManager:
         )
         job["control_generation"] = legacy
         job["accepted_generations"] = accepted
-        if previous is None:
-            for role in job.get("roles", []):
-                if _runtime_generation(role) == legacy:
-                    updates = {
-                        "reimport_required": True,
-                        "imported": False,
-                        "queued": False,
-                        "model_prepared": False,
-                    }
-                    for key, value in updates.items():
-                        if role.get(key) != value:
-                            role[key] = value
-                            changed = True
+        for role in job.get("roles", []):
+            if (_runtime_generation(role) == legacy
+                    and role.get("reimport_from_generation") != legacy):
+                # The old report survives QMT shutdown and import. Handle it
+                # once per replacement job, including across Web restarts;
+                # resetting every poll destroys the prepared/imported model.
+                updates = {
+                    "reimport_from_generation": legacy,
+                    "reimport_required": True,
+                    "imported": False,
+                    "queued": False,
+                    "model_prepared": False,
+                }
+                for key, value in updates.items():
+                    if role.get(key) != value:
+                        role[key] = value
+                        changed = True
         if changed and job.get("state") == "error":
             self._state(job, "waiting_exit")
         return changed

{cfquant-0.2.48 → cfquant-0.2.50}/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

@@ -1091,7 +1091,7 @@ def test_local_query_does_not_swallow_internal_type_error():
     ("xtdata.get_full_tick", {}, "trade"),
     ("xtdata.get_instrument_detail", {}, "trade"),
     ("xtdata.get_cb_info", {}, "trade"),
-    ("xtdata.get_local_data", {}, "trade"),
+    ("xtdata.get_local_data", {}, "normal"),
     ("xtdata.subscribe_quote", {}, "normal"),
     ("xtdata.subscribe_whole_quote", {}, "normal"),
     ("xtdata.get_market_data_ex", {"callback_event": "probe"}, "normal"),

cfquant-0.2.50/cfquant/tests/test_advanced_parity.py

@@ -0,0 +1,153 @@
+"""Offline regressions for split-QMT account setup and downloaded data."""
+import ast
+import os
+from pathlib import Path
+from types import SimpleNamespace
+import tokenize
+
+import pandas as pd
+import pytest
+
+import cfquant_web_server as web
+from cfquant.normal_bridge import NormalQmtBridge
+from cfquant.pipe_bridge import PipeNormalQmtBridge, PipeTradeBridge
+from cfquant.tx_trade_bridge import TxTradeBridge
+from cfquant.tests.test_lite_parity import LITE_PATHS, _lite_bridge_class
+
+
+ROOT = Path(__file__).resolve().parents[2]
+TRADE_ENTRIES = sorted((ROOT / "qmt_scripts").rglob("CFQUANT_TRADE_LOWLAT*.py"))
+
+
+@pytest.mark.parametrize("path", TRADE_ENTRIES, ids=lambda path: path.stem)
+@pytest.mark.parametrize("source", ["runtime", "environment"])
+def test_advanced_trade_entry_binds_credit_account_before_init(monkeypatch, path, source):
+    for name in ("CFQUANT_ACCOUNT_ID", "CFQUANT_ACCOUNT_TYPE"):
+        monkeypatch.delenv(name, raising=False)
+    identity = {"account_id": "C123", "account_type": "CREDIT"}
+    if source == "environment":
+        for name, value in identity.items():
+            monkeypatch.setenv("CFQUANT_" + name.upper(), value)
+    with tokenize.open(str(path)) as stream:
+        tree = ast.parse(stream.read())
+    bridge = SimpleNamespace(account_type="", run_forever=lambda **kwargs: None)
+    bound = []
+    bridge.set_context = lambda context: bound.append((bridge.account_id, bridge.account_type))
+
+    def start(context, **kwargs):
+        bridge.account_id = kwargs["account_id"]
+        return bridge
+
+    namespace = dict(os=os, BRIDGE_ID="test", RUNTIME_CONFIG={}, RUNTIME_CHANNELS={},
+                     QMT_MARKET="", USER_BRIDGE_ID="default", BRIDGE_CHANNELS={"trade": "trade"},
+                     _load_runtime_config=lambda: identity if source == "runtime" else {},
+                     _env_allows_runtime_override=lambda *args: True,
+                     _print_log=lambda *args: None, _ENTRY_VERSION="test",
+                     start_tx_trade_bridge=start)
+    # Execute account setup and bridge construction from each shipped entry,
+    # omitting imports and transport startup so this cannot contact a live QMT.
+    nodes = []
+    for node in tree.body:
+        if isinstance(node, ast.Assign) and any(
+            isinstance(target, ast.Name) and target.id in ("DEFAULT_ACCOUNT_ID", "DEFAULT_ACCOUNT_TYPE")
+            for target in node.targets
+        ):
+            nodes.append(node)
+        elif isinstance(node, ast.FunctionDef) and node.name in ("_apply_runtime_config", "_config_bool", "init"):
+            nodes.append(node)
+    exec(compile(ast.Module(body=nodes, type_ignores=[]), str(path), "exec"), namespace)
+    namespace["_apply_runtime_config"]()
+    nodes = [node for node in tree.body if (
+        isinstance(node, ast.Assign) and isinstance(node.value, ast.Call)
+        and isinstance(node.value.func, ast.Name) and node.value.func.id == "start_tx_trade_bridge"
+    ) or (isinstance(node, ast.If) and "DEFAULT_ACCOUNT_TYPE" in ast.unparse(node.test))]
+    exec(compile(ast.Module(body=nodes, type_ignores=[]), str(path), "exec"), namespace)
+    namespace["init"](object())
+    assert bound == [("C123", "CREDIT")]
+
+
+@pytest.mark.parametrize("mode", ["lttx", "ctypes"])
+@pytest.mark.parametrize("requested_channel", [None, "trade"])
+@pytest.mark.parametrize("read_action", [
+    "get_local_data", "get_market_data", "get_market_data_ex", "get_financial_data",
+    "get_financial_data_ori", "get_financial_data_raw",
+])
+def test_download_then_read_uses_same_qmt_storage(monkeypatch, mode, requested_channel, read_action):
+    stores = {"normal": {}, "trade": {}}
+    if mode == "ctypes":
+        stores["trade"] = stores["normal"]
+    frames = {"000001.SZ": pd.DataFrame({"close": [11.6]})}
+
+    def functions(store):
+        return {
+            "download_history_data": lambda *args: store.update(history=frames),
+            "download_financial_data": lambda *args: store.update(financial=frames),
+            "get_market_data_ex": lambda *args: store.get("history", {}),
+            "get_financial_data": lambda *args: store.get("financial", {}),
+            "get_raw_financial_data": lambda *args: store.get("financial", {}),
+        }
+
+    normal_cls, trade_cls = (NormalQmtBridge, TxTradeBridge) if mode == "lttx" else (PipeNormalQmtBridge, PipeTradeBridge)
+    bridges = {channel: cls(object(), globals_dict=functions(stores[channel]), show=False)
+               for channel, cls in (("normal", normal_cls), ("trade", trade_cls))}
+    monkeypatch.setattr(web, "WEB_CONFIG", None)
+    monkeypatch.setattr(web, "resolve_bridge_id", lambda **kwargs: "test")
+    monkeypatch.setattr(web, "resolve_account_mode", lambda *args, **kwargs: mode)
+    monkeypatch.setattr(web, "resolve_market_route_for_request", lambda **kwargs: ("test", None))
+    calls = []
+
+    def request(bridge_id, channel, action, params, **kwargs):
+        calls.append((action, channel))
+        return bridges[channel]._dispatch(action, params, {"client_id": "offline"})
+
+    monkeypatch.setattr(web.CLIENTS, "request", request)
+    params = {"stock_code": "000001.SZ", "stock_list": ["000001.SZ"],
+              "field_list": ["close"], "period": "1d"}
+    download = "download_financial_data" if "financial" in read_action else "download_history_data"
+    web.account_request("C123", "test", requested_channel, "xtdata." + download, params)
+    result = web.account_request("C123", "test", requested_channel, "xtdata." + read_action, params)["result"]
+    assert result, calls
+    assert calls == [("xtdata." + download, "normal"), ("xtdata." + read_action, "normal")]
+
+
+@pytest.mark.parametrize("action", ["xtdata.get_market_data", "xtdata.get_market_data_ex"])
+@pytest.mark.parametrize("period", ["l2quote", "l2order", "l2transaction"])
+def test_level2_market_reads_keep_trade_channel(action, period):
+    assert web.route_channel_for_account("C123", mode="lttx", action=action,
+                                         params={"period": period}) == "trade"
+
+
+BRIDGES = [TxTradeBridge, NormalQmtBridge, PipeTradeBridge, PipeNormalQmtBridge]
+BRIDGES += [_lite_bridge_class(path) for path in LITE_PATHS]
+
+
+@pytest.mark.parametrize("bridge_cls", BRIDGES)
+@pytest.mark.parametrize("raw", [
+    {"success": "false", "msg": "rejected", "apply_id": "-1"},
+    {"success": True, "msg": "accepted", "apply_id": []},
+    {"success": True, "msg": "accepted", "apply_id": True},
+    {"success": True, "apply_id": "A1"},
+])
+def test_all_modes_reject_malformed_smt_response(bridge_cls, raw):
+    bridge = bridge_cls(object(), show=False, globals_dict={"smt_appointment_cancel": lambda *args: raw})
+    bridge._send_trader_event = lambda *args: pytest.fail("malformed response delivered")
+    with pytest.raises(RuntimeError, match="business response"):
+        bridge._dispatch("xttrader.smt_appointment_cancel", {
+            "account": {"account_id": "C123", "account_type": "CREDIT"}, "seq": 1, "args": ["A1"],
+        }, {"client_id": "offline"})
+
+
+@pytest.mark.parametrize("bridge_cls", BRIDGES)
+def test_all_modes_accept_native_smt_fields(bridge_cls):
+    raw = type("BrokerResponse", (), dict(__slots__=(), m_bSuccess=True,
+               m_strMsg="accepted", m_strApplyID="000123", m_nSeq=987))()
+    bridge = bridge_cls(object(), show=False, globals_dict={"smt_appointment_cancel": lambda *args: raw})
+    events = []
+    bridge._send_trader_event = lambda client, event, data: events.append(data)
+    result = bridge._dispatch("xttrader.smt_appointment_cancel", {
+        "account": {"account_id": "C123", "account_type": "CREDIT"}, "seq": 1, "args": ["A1"],
+    }, {"client_id": "offline"})
+    assert result == {"seq": 1, "accepted": True}
+    assert len(events) == 1
+    assert events[0]["success"] is True and events[0]["apply_id"] == "000123"
+    assert events[0]["seq"] == 1

{cfquant-0.2.48 → cfquant-0.2.50}/cfquant/tests/test_lite_deployment_paths.py

@@ -98,6 +98,35 @@ def test_edit_without_mode_preserves_lite_binding_and_payload(web_deployment):
     assert_lite_package(manager, root)
 
 
+def test_edit_advanced_binding_to_lite_retires_both_advanced_models(web_deployment):
+    web, manager, row, infos, root = web_deployment
+    trade_root = root.with_name("QMT_trade")
+    shutil.copytree(root, trade_root)
+    row.update(mode="lttx", qmt_trade_dir=str(trade_root / "bin.x64"))
+    row["qmt_strategy"]["autorun"] = True
+    trade_info = dict(infos[0], qmt_role="trade", core_dir=str(trade_root / "bin.x64"),
+                      path=str(trade_root / "bin.x64" / "cfquant_bridge_config.json"))
+    manager.configure(row, infos + [trade_info])
+    advanced_name = "CFQ_%s_LTTX" % row["account_id"]
+    assert models(root)[advanced_name].getAttribute("startupAutorun") == "1"
+    assert models(trade_root)[advanced_name].getAttribute("startupAutorun") == "1"
+
+    body = {key: row[key] for key in ("account_id", "account_type", "bridge_id", "qmt_dir")}
+    result = web.save_account_runtime_config(dict(body, mode="lite", qmt_trade_dir=""))
+
+    assert result["account"]["mode"] == "lite"
+    assert result["account"]["qmt_trade_dir"] == ""
+    assert not result["qmt_strategy_deploy"].get("error")
+    job = assert_lite_package(manager, root)
+    assert job["roles"][0]["name"] == "CFQ_%s_LITE" % row["account_id"]
+    assert models(root)[job["roles"][0]["name"]].getAttribute("startupAutorun") == "1"
+    assert models(root)[advanced_name].getAttribute("startupAutorun") == "0"
+    assert models(trade_root)[advanced_name].getAttribute("startupAutorun") == "0"
+    trade_job = next(job for job in manager.jobs.values() if job["root"] == str(trade_root))
+    assert trade_job["enabled"] is False
+    assert trade_job["state"] == "disabled"
+
+
 @pytest.mark.parametrize("single_account", [False, True])
 def test_shared_qmt_directory_does_not_drop_lite_market_entries(single_account, web_deployment):
     web, _, row, _, root = web_deployment

cfquant-0.2.50/cfquant/tests/test_lite_parity.py

@@ -0,0 +1,140 @@
+"""Focused runtime checks for the standalone Lite compatibility adapters."""
+
+import ast
+from pathlib import Path
+from types import SimpleNamespace
+
+import pandas as pd
+
+from cfquant import level2
+from cfquant.tx_trade_bridge import TxTradeBridge
+
+
+ROOT = Path(__file__).resolve().parents[2]
+LITE_PATHS = sorted((ROOT / "qmt_scripts").rglob("CFQUANT_LITE*.py"))
+
+
+def _lite_bridge_class(path):
+    source = path.read_bytes().decode("gbk")
+    tree = ast.parse(source)
+    class_node = next(
+        node for node in tree.body
+        if isinstance(node, ast.ClassDef) and node.name == "TxTradeBridge"
+    )
+    methods = {
+        "_dispatch_xtdata_compat", "_get_market_data", "_get_market_data_ex",
+        "_get_local_data", "_call_local_data", "_dispatch_xttrader_compat",
+        "_query_account_id", "_credit_account_id", "_call_trade_detail_data",
+        "_credit_row_data", "_credit_field_value", "_format_credit_rows",
+        "_query_credit_detail", "_query_qmt_objects", "_query_stk_compacts",
+        "_smt_request", "_smt_response_data", "_format_transfer_result", "_format_compat_query_objects",
+        "_format_compat_query_object", "_known_query_fields", "_plain_object",
+        "_first_present",
+    }
+    class_node.bases = [ast.Name(id="BaseTradeBridge", ctx=ast.Load())]
+    class_node.body = [
+        node for node in class_node.body
+        if isinstance(node, ast.FunctionDef) and node.name in methods
+    ]
+    constants = {
+        "SMT_ASYNC_ARGUMENT_COUNTS", "XTTRADER_TRANSFER_RESULT_METHODS",
+        "LITE_OBJECT_QUERY_METHODS", "_LITE_CREDIT_FIELD_ALIASES",
+        "L2_GET_PERIODS", "L2_PERIODS", "KLINE_PERIODS",
+        "XTDATA_COMPAT_CANDIDATES", "XTDATA_MAINCHAIN_UNSUPPORTED",
+    }
+    body = [
+        node for node in tree.body
+        if isinstance(node, ast.Assign)
+        and any(isinstance(target, ast.Name) and target.id in constants for target in node.targets)
+    ]
+    body.append(class_node)
+    module = ast.Module(body=body, type_ignores=[])
+    namespace = dict(vars(__import__("cfquant.tx_trade_bridge", fromlist=["*"])))
+    namespace.update(
+        BaseTradeBridge=TxTradeBridge,
+        market_data_result_needs_fallback=level2.market_data_result_needs_fallback,
+    )
+    exec(compile(ast.fix_missing_locations(module), str(path), "exec"), namespace)
+    return namespace["TxTradeBridge"]
+
+
+class _FakeQmt:
+    def __init__(self):
+        self.calls = []
+
+    def get_market_data(self, *args):
+        self.calls.append(("legacy", args))
+        return pd.DataFrame()
+
+    def get_market_data_ex(self, *args):
+        self.calls.append(("modern", args))
+        return {"000001.SZ": pd.DataFrame({"close": [11.6]})}
+
+    def get_trade_detail_data(self, account_id, account_type, detail_type, strategy_name):
+        self.calls.append(("detail", account_id, account_type, detail_type, strategy_name))
+        if detail_type == "account":
+            return [SimpleNamespace(m_strAccountID=account_id, m_dBalance=100.0, m_dFinUsedQuota=8.0)]
+        return []
+
+    def get_unclosed_compacts(self, account_id, account_type):
+        self.calls.append(("compact", account_id, account_type))
+        return [SimpleNamespace(m_strAccountID=account_id, m_strInstrumentID="000001", m_eCompactType=1)]
+
+
+def _bridge(path):
+    bridge = _lite_bridge_class(path)(_FakeQmt(), account_id="CREDIT-1", show=False)
+    bridge._log = lambda *args, **kwargs: None
+    bridge.tx = SimpleNamespace(push=lambda *args, **kwargs: None)
+    return bridge
+
+
+def test_all_lite_entries_contain_shared_data_and_credit_adapters():
+    expected = {
+        "_get_market_data", "_get_local_data", "_get_instrument_detail",
+        "_get_cb_info", "_get_divid_factors", "_get_stock_list_in_sector",
+        "_query_credit_detail", "_query_stk_compacts", "_call_trade_detail_data",
+    }
+    for path in LITE_PATHS:
+        tree = ast.parse(path.read_bytes().decode("gbk"))
+        bridge = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "TxTradeBridge")
+        names = {node.name for node in bridge.body if isinstance(node, ast.FunctionDef)}
+        assert expected <= names, path
+
+
+def test_lite_credit_detail_supports_qmt_four_argument_signature():
+    bridge = _bridge(LITE_PATHS[0])
+    result = bridge._dispatch(
+        "xttrader.query_credit_detail",
+        {"account": {"account_id": "CREDIT-1", "account_type": "CREDIT"}},
+        {"client_id": "test"},
+    )
+    assert result[0]["account_id"] == "CREDIT-1"
+    assert result[0]["account_type"] == 3
+    assert result[0]["cfquant_qmt_fields"]["m_dFinUsedQuota"] == 8.0
+    assert result[0]["cfquant_source"] == "get_trade_detail_data"
+    assert ("detail", "CREDIT-1", "credit", "account", "") in bridge.context.calls
+
+
+def test_lite_credit_compacts_and_market_fallback_match_common_contract():
+    bridge = _bridge(LITE_PATHS[0])
+    compact = bridge._dispatch(
+        "xttrader.query_stk_compacts",
+        {"account_id": "CREDIT-1", "account_type": "CREDIT"},
+        {"client_id": "test"},
+    )
+    assert compact[0]["account_id"] == "CREDIT-1"
+    assert compact[0]["instrument_id"] == "000001"
+
+    result = bridge._dispatch(
+        "xtdata.get_market_data",
+        {"field_list": ["close"], "stock_list": ["000001.SZ"], "period": "1d"},
+        {"client_id": "test"},
+    )
+    assert "close" in result
+    local = bridge._dispatch(
+        "xtdata.get_local_data",
+        {"field_list": ["close"], "stock_list": ["000001.SZ"], "period": "1d"},
+        {"client_id": "test"},
+    )
+    assert "000001.SZ" in local
+    assert any(call[0] == "modern" and len(call[1]) == 9 for call in bridge.context.calls)