cfquant 0.2.66__tar.gz → 0.2.68__tar.gz

{cfquant-0.2.66 → cfquant-0.2.68}/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.68}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cfquant
-Version: 0.2.66
+Version: 0.2.68
 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.68}/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.68}/cfquant/__init__.py

@@ -12,7 +12,7 @@ cfquant: 面向 QMT 的 xtquant 兼容层。
 import sys as _sys
 
 from . import xtconstant, xtdata, xttrader, xttype
-from . import cftrader
+from . import cftrader, notify
 from .qmt_inner import QmtInnerApi
 from .client import CfquantError, CfquantTimeout, configure, get_client
 from .version import __version__
@@ -28,6 +28,7 @@ __all__ = [
     "xtdata",
     "xttrader",
     "cftrader",
+    "notify",
     "QmtInnerApi",
     "xttype",
     "configure",

{cfquant-0.2.66 → cfquant-0.2.68}/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.68}/cfquant/client.py

@@ -472,6 +472,8 @@ def configure(**kwargs):
     from .config import configure as configure_config
 
     configure_config(**kwargs)
+    from . import notify
+    notify.close()
     global _default_client
     with _client_lock:
         if _default_client is not None:

{cfquant-0.2.66 → cfquant-0.2.68}/cfquant/monitor_notifications.py

@@ -6,11 +6,9 @@ never perform SMTP or HTTP work on a QMT callback/status thread.
 """
 
 import copy
-import base64
 from datetime import datetime, timedelta, timezone
 from email.message import EmailMessage
 import hashlib
-import hmac
 import json
 import os
 from pathlib import Path
@@ -20,9 +18,7 @@ import ssl
 import tempfile
 import threading
 import time
-import urllib.error
-import urllib.parse
-import urllib.request
+from .webhook import send_webhook
 
 
 SHANGHAI = timezone(timedelta(hours=8))
@@ -566,28 +562,5 @@ class MonitorNotificationService:
                 server.send_message(msg)
 
     def _send_webhook(self, config, event):
-        url = str(config.get("url") or "").strip()
-        if not url:
-            raise ValueError("webhook url is required")
-        kind = str(config.get("type") or "generic").lower()
-        if kind == "dingtalk" and config.get("secret"):
-            timestamp = str(int(time.time() * 1000))
-            secret = str(config.get("secret"))
-            raw = "%s\n%s" % (timestamp, secret)
-            sign = base64.b64encode(hmac.new(secret.encode("utf-8"), raw.encode("utf-8"), hashlib.sha256).digest()).decode("ascii")
-            separator = "&" if "?" in url else "?"
-            url = "%s%stimestamp=%s&sign=%s" % (url, separator, urllib.parse.quote(timestamp), urllib.parse.quote(sign))
-        text = self._format_text(event)
-        if kind == "feishu":
-            body = {"msg_type": "text", "content": {"text": text}}
-        elif kind in ("dingtalk", "wecom"):
-            body = {"msgtype": "text", "text": {"content": text}}
-        else:
-            body = {"event_type": event.get("event_type"), "title": event.get("title"),
-                    "message": event.get("message"), "payload": event.get("payload"),
-                    "occurred_at": event.get("occurred_at")}
-        request = urllib.request.Request(url, data=json.dumps(body, ensure_ascii=False, default=str).encode("utf-8"),
-                                         headers={"Content-Type": "application/json; charset=utf-8", "User-Agent": "cfquant-monitor"}, method="POST")
-        with urllib.request.urlopen(request, timeout=8) as response:
-            if int(getattr(response, "status", 200)) >= 400:
-                raise urllib.error.HTTPError(url, response.status, "webhook returned %s" % response.status, response.headers, None)
+        payload = {key: event.get(key) for key in ("event_type", "title", "message", "payload", "occurred_at")}
+        return send_webhook(config, self._format_text(event), payload=payload)

cfquant-0.2.68/cfquant/notify.py

@@ -0,0 +1,52 @@
+"""User-authored messages: explicit Webhook first, otherwise account binding."""
+
+import atexit
+import threading
+
+from .webhook import WebhookError, normalize_webhook, send_webhook, validate_message
+
+_client = None
+_client_lock = threading.Lock()
+
+
+def close():
+    """Release the notification RPC connection; the next call reconnects."""
+    global _client
+    with _client_lock:
+        client, _client = _client, None
+    if client is not None:
+        client.close()
+
+
+atexit.register(close)
+
+
+def send(message, account_id=None, *, title="", webhook_url=None, provider=None,
+         secret=None, account_type=None, account_key=None, bridge_id=None, timeout=8):
+    """Send text synchronously; returns sent/provider/source, or raises on failure.
+
+    webhook_url and provider must be supplied together and override the binding
+    completely (including its secret). Account-based sends require cfquant Web
+    and LTtx, but do not require QMT to be online. No automatic retry is performed.
+    """
+    timeout = validate_message(message, title, timeout)
+    if webhook_url is not None or provider is not None or secret is not None:
+        if not webhook_url or not provider:
+            raise ValueError("调用时覆盖推送配置必须同时提供 webhook_url 和 provider")
+        config = normalize_webhook({"enabled": True, "url": webhook_url, "provider": provider, "secret": secret})
+        return dict(send_webhook(config, message, title=title, timeout=timeout), source="explicit")
+    if not str(account_id or "").strip() and not str(account_key or "").strip():
+        raise ValueError("请指定资金账号 account_id 或 account_key，或提供 webhook_url 和 provider")
+    params = {"message": message, "title": title, "timeout": timeout}
+    params.update({key: value for key, value in dict(account_id=account_id, account_type=account_type,
+        account_key=account_key, bridge_id=bridge_id).items() if value is not None})
+    global _client
+    with _client_lock:
+        if _client is None:
+            from .client import create_rpc_client
+            _client = create_rpc_client(transport="web_lttx")
+        client = _client
+    return client.request("cfquant.notify.send", params, timeout=timeout + 5)
+
+
+__all__ = ["send", "close", "WebhookError"]

{cfquant-0.2.66 → cfquant-0.2.68}/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.68}/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.66 → cfquant-0.2.68}/cfquant/qmt_bridge.py

@@ -1,6 +1,7 @@
 from .diagnostic_context import versioned_message
 # -*- coding: utf-8 -*-
 import os
+import gc
 import queue
 import sys
 import threading
@@ -516,47 +517,91 @@ class CfquantQmtBridge(object):
                 })
             raise NotImplementedError("当前QMT环境未提供download_history_data2")
 
-        def callback(data):
+        stock_list = params.get("stock_list", params.get("code_list", []))
+        if isinstance(stock_list, str):
+            stock_list = [item.strip() for item in stock_list.replace("，", ",").split(",") if item.strip()]
+        else:
+            stock_list = list(stock_list or [])
+        batches = self._history_download_batches(stock_list, params)
+        total = len(stock_list)
+        completed = 0
+
+        def callback(data, batch_offset=0, batch_index=0, batch_total=1):
             if callback_event and client_id:
+                payload = dict(data) if isinstance(data, dict) else {"message": str(data)}
+                batch_finished = payload.get("finished")
+                try:
+                    batch_finished = max(0, min(int(batch_finished), len(batches[batch_index])))
+                except (TypeError, ValueError, IndexError):
+                    batch_finished = 0
+                payload.update({
+                    "finished": min(total, batch_offset + batch_finished),
+                    "total": total,
+                    "batch_index": batch_index + 1,
+                    "batch_total": batch_total,
+                    "batch_finished": batch_finished,
+                    "batch_size": len(batches[batch_index]) if batch_index < len(batches) else 0,
+                })
                 self._send_event(
                     client_id,
                     callback_event,
-                    data,
+                    payload,
                     meta=self._download_event_meta(params, "history", "progress"),
                 )
 
-        callback_func = callback if callback_event else None
-        variants = []
-        incrementally = params.get("incrementally")
-        if incrementally is not None:
-            variants.append((
-                (
-                    params.get("stock_list", params.get("code_list", [])),
-                    params.get("period", "1d"),
-                    params.get("start_time", ""),
-                    params.get("end_time", ""),
-                    callback_func,
-                    incrementally,
-                ),
-                {},
-            ))
-        variants.append((
-            (
-                params.get("stock_list", params.get("code_list", [])),
-                params.get("period", "1d"),
-                params.get("start_time", ""),
-                params.get("end_time", ""),
-                callback_func,
-            ),
-            {},
-        ))
         if emit_lifecycle:
             self._send_download_event(client_id, params, "history", "submitted", {
                 "stage": "submitted",
                 "message": "history download request submitted",
+                "total": total,
+                "batch_total": len(batches),
+                "batch_size": self._history_download_batch_size(params),
             })
         try:
-            result = self._call_variants(func, variants)
+            incrementally = params.get("incrementally")
+            batch_total = len(batches)
+            for batch_index, batch in enumerate(batches):
+                batch_offset = completed
+                callback_func = (
+                    (lambda data, offset=batch_offset, index=batch_index:
+                     callback(data, offset, index, batch_total))
+                    if callback_event else None
+                )
+                variants = []
+                if incrementally is not None:
+                    variants.append((
+                        (
+                            batch,
+                            params.get("period", "1d"),
+                            params.get("start_time", ""),
+                            params.get("end_time", ""),
+                            callback_func,
+                            incrementally,
+                        ),
+                        {},
+                    ))
+                variants.append((
+                    (
+                        batch,
+                        params.get("period", "1d"),
+                        params.get("start_time", ""),
+                        params.get("end_time", ""),
+                        callback_func,
+                    ),
+                    {},
+                ))
+                self._call_variants(func, variants)
+                completed += len(batch)
+                if emit_lifecycle:
+                    self._send_download_event(client_id, params, "history", "batch_done", {
+                        "stage": "batch_done",
+                        "finished": completed,
+                        "total": total,
+                        "batch_index": batch_index + 1,
+                        "batch_total": batch_total,
+                        "batch_size": len(batch),
+                    })
+                gc.collect()
         except Exception as e:
             if emit_lifecycle:
                 self._send_download_event(client_id, params, "history", "error", {
@@ -567,9 +612,39 @@ class CfquantQmtBridge(object):
         if emit_lifecycle:
             self._send_download_event(client_id, params, "history", "request_done", {
                 "stage": "request_done",
-                "result": result,
+                "result": None,
+                "finished": completed,
+                "total": total,
             })
-        return result
+        return None
+
+    @staticmethod
+    def _history_download_batch_size(params):
+        params = params or {}
+        value = params.get("download_batch_size", params.get("batch_size"))
+        if value is None:
+            value = os.environ.get("CFQUANT_HISTORY_DOWNLOAD_BATCH_SIZE")
+        if value is None or str(value).strip() == "":
+            period = str(params.get("period") or "").lower()
+            if period == "tick":
+                return 20
+            if period == "1m":
+                return 50
+            if period.endswith("m") or period.endswith("h"):
+                return 100
+            return 200
+        try:
+            value = int(value)
+        except (TypeError, ValueError):
+            return 50
+        return max(1, value)
+
+    @classmethod
+    def _history_download_batches(cls, stock_list, params):
+        if not stock_list:
+            return [stock_list]
+        size = cls._history_download_batch_size(params)
+        return [stock_list[index:index + size] for index in range(0, len(stock_list), size)]
 
     def _get_instrument_detail(self, params):
         func = getattr(self.context, "get_instrument_detail")