cfquant 0.2.67__tar.gz → 0.2.68__tar.gz

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

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

{cfquant-0.2.67 → 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.67 → 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.67 → 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.67 → 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")

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

@@ -593,7 +593,8 @@ class QmtPythonRuntime:
             time.sleep(0.25)
         raise QmtPythonRuntimeError("QMT did not start after runtime switch")
 
-    def validate_selection(self, runtime, *, account_id=None):
+    def validate_selection(self, runtime, *, account_id=None,
+                           allow_missing_account_config=False):
         runtime = _canonical_runtime(runtime)
         effective_account = account_id if account_id is not None else self.account_id
         binding = self.binding_status(account_id=effective_account)
@@ -603,6 +604,8 @@ class QmtPythonRuntime:
                 % (binding.get("qmt_version") or "unknown"))
         if effective_account:
             if not binding["config_exists"]:
+                if allow_missing_account_config and binding["state"] == "account_config_missing":
+                    return binding
                 raise QmtPythonRuntimeError("QMT account Config.xml not found: %s; log in to QMT first" % effective_account)
             text = Path(binding["config"]).read_text(encoding="utf-8")
             if not re.search(r'<python\b[^>]*\blibs_path="[^"]*"', text):
@@ -611,9 +614,19 @@ class QmtPythonRuntime:
 
     def download_and_switch(self, runtime="py312", *, restart=True, account_id=None,
                             progress_callback=None, cancel_event=None,
-                            restart_callback=None, reuse_installed=False):
+                            restart_callback=None, reuse_installed=False,
+                            allow_missing_account_config=False):
         runtime = _canonical_runtime(runtime)
-        binding = self.validate_selection(runtime, account_id=account_id)
+        binding = self.validate_selection(
+            runtime,
+            account_id=account_id,
+            allow_missing_account_config=allow_missing_account_config,
+        )
+        deferred_account_config = bool(
+            allow_missing_account_config
+            and (account_id or self.account_id)
+            and binding.get("state") == "account_config_missing"
+        )
         reuse = bool(reuse_installed and binding["runtimes"][runtime]["installed"])
         package, archive = None, None
         if reuse:
@@ -624,17 +637,25 @@ class QmtPythonRuntime:
                                     cancel_event=cancel_event)
         if cancel_event and cancel_event.is_set():
             raise QmtPythonRuntimeError("QMT Python runtime operation cancelled")
-        _callback(progress_callback, QmtPythonProgress(runtime, "activating", message="正在停止 QMT 并配置执行器"))
-        if restart and self._qmt_processes():
+        _callback(progress_callback, QmtPythonProgress(
+            runtime, "activating",
+            message=("正在停止 QMT 并安装运行库" if deferred_account_config
+                     else "正在停止 QMT 并配置执行器"),
+        ))
+        was_running = bool(self._qmt_processes())
+        if restart and was_running:
             self._stop_for_switch()
-        elif not restart and self._qmt_processes():
+        elif not restart and was_running:
             raise QmtPythonRuntimeError(
-                "QMT is running; set restart=True before activating a Python runtime")
+                "QMT is running; set restart=True before installing or activating a Python runtime")
         try:
             installed = self.inspect(runtime, refresh_remote=False) if reuse else self.install(runtime, package=package, progress_callback=progress_callback)
-            switched = self.switch_account(runtime, account_id=account_id) if (account_id or self.account_id) else None
+            switched = None if deferred_account_config else (
+                self.switch_account(runtime, account_id=account_id)
+                if (account_id or self.account_id) else None
+            )
         finally:
-            if restart:
+            if restart and (not deferred_account_config or was_running):
                 _callback(progress_callback, QmtPythonProgress(runtime, "restarting", message="正在重新启动 QMT"))
                 if restart_callback:
                     restarted = restart_callback()
@@ -646,7 +667,10 @@ class QmtPythonRuntime:
                 restarted = None
         return {"runtime": runtime, "package": package.as_dict() if package else None,
                 "archive": str(archive) if archive else None, "reused_installed": reuse,
-                "installed": installed, "switched": switched, "restarted": restarted}
+                "installed": installed, "switched": switched, "restarted": restarted,
+                "account_config_required": deferred_account_config,
+                "message": ("运行库已安装；请先在 QMT 登录此账号，再重新检测并应用执行器。"
+                             if deferred_account_config else "")}
 
     def _stop_for_switch(self):
         for process in self._qmt_processes():

{cfquant-0.2.67 → cfquant-0.2.68}/cfquant/tests/test_binding_python_runtime_browser.py

@@ -119,6 +119,13 @@ def test_missing_account_config_shows_capabilities_but_requires_login(page, fron
     errors = open_runtime(page, frontend_url, runtime_status(config_exists=False))
     expect(page.locator("#bindingPythonRuntimeSelect option")).to_have_count(2)
     page.locator("#bindingPythonRuntimeSelect").select_option("py312")
-    expect(page.locator("#bindingPythonRuntimeDownloadBtn")).to_be_disabled()
-    expect(page.locator("#bindingPythonRuntimeChoiceHint")).to_contain_text("登录")
+    submitted = []
+    page.route("**/api/qmt/python-runtime/download", lambda route: (
+        submitted.append(route.request.post_data_json),
+        route.fulfill(json={"ok": True, "data": {"state": "queued"}})))
+    expect(page.locator("#bindingPythonRuntimeDownloadBtn")).to_be_enabled()
+    expect(page.locator("#bindingPythonRuntimeChoiceHint")).to_contain_text("先下载")
+    page.locator("#bindingPythonRuntimeDownloadBtn").click()
+    page.wait_for_function("state.bindingPythonRuntimeJobId")
+    assert submitted[0]["allow_missing_account_config"] is True
     assert not errors

cfquant-0.2.68/cfquant/tests/test_binding_webhook_browser.py

@@ -0,0 +1,106 @@
+"""Account Webhook editing and docs on desktop/mobile; all APIs are offline."""
+import ast
+import inspect
+
+from cfquant import notify
+from cfquant.tests.test_tutorial_reader import browser, page, frontend_url, expect
+from cfquant.tests.test_binding_runtime_browser import open_bindings
+
+
+def test_new_binding_webhook_save_edit_preserves_credentials_and_clears(page, frontend_url, tmp_path):
+    _, errors = open_bindings(page, frontend_url)
+    page.locator('#openBindingDialogBtn').click()
+    page.locator('#bindingAccountId').fill('TEST_ONLY')
+    page.evaluate("fillQmtStrategySettings('binding', {enabled: false})")
+    page.locator('#bindingQmtAutoLogin').uncheck()
+    expect(page.locator('#bindingWebhookFields')).not_to_be_visible()
+    expect(page.locator('#bindingWebhookSaveBtn')).not_to_be_visible()
+    page.locator('#bindingWebhookEnabled').check()
+    page.locator('#bindingWebhookProvider').select_option('feishu')
+    page.locator('#bindingWebhookUrl').fill('https://example.invalid/PRIVATE_TOKEN')
+    page.locator('#bindingWebhookSecret').fill('PRIVATE_SECRET')
+    saved = []
+    rows = {}
+
+    def save(route):
+        body = route.request.post_data_json
+        saved.append(body)
+        row = dict(body, account_key='test:STOCK:TEST_ONLY', bridge_id='test', notification_webhook={
+            'enabled': True, 'provider': 'feishu', 'url': '', 'secret': '',
+            'url_configured': True, 'secret_configured': True})
+        rows[row['account_key']] = row
+        route.fulfill(json={'ok': True, 'data': {'account': row, 'account_configs': rows,
+            'account_pairs': {}, 'bridges': {'test': {'name': 'Test'}},
+            'qmt_strategy_deploy': {'enabled': False}, 'qmt_auto_login': {'enabled': False}}})
+
+    page.route('**/api/account-config', save)
+    page.locator('#bindingForm [type="submit"]').click()
+    expect(page.locator('#bindingDialogOverlay')).not_to_be_visible()
+    assert saved[0]['notification_webhook'] == {'enabled': True, 'provider': 'feishu',
+        'url': 'https://example.invalid/PRIVATE_TOKEN', 'secret': 'PRIVATE_SECRET', 'clear_secret': False}
+    assert page.locator('#bindingWebhookUrl').input_value() == ''
+    page.evaluate("""() => {
+        document.querySelector('#bindingQmtGuideOverlay').classList.add('hidden');
+        openBindingDialog({accountKey: 'test:STOCK:TEST_ONLY'});
+    }""")
+    expect(page.locator('#bindingWebhookProvider')).to_have_value('feishu')
+    expect(page.locator('#bindingWebhookUrlHint')).to_contain_text('已配置')
+    expect(page.locator('#bindingWebhookSecret')).to_have_value('')
+    updates = []
+
+    def partial(route):
+        body = route.request.post_data_json
+        updates.append(body)
+        row = rows[body['account_key']]
+        if body['notification_webhook'].get('clear'):
+            row['notification_webhook'] = {'enabled': False, 'provider': 'wecom',
+                'url_configured': False, 'secret_configured': False}
+        route.fulfill(json={'ok': True, 'data': {'account': row}})
+
+    page.route('**/api/account-config/webhook', partial)
+    page.locator('#bindingWebhookSaveBtn').click()
+    expect(page.locator('#bindingWebhookSaveStatus')).to_contain_text('已保存')
+    assert 'url' not in updates[0]['notification_webhook']
+    assert 'secret' not in updates[0]['notification_webhook']
+    assert len(saved) == 1
+    page.locator('#bindingWebhookProvider').select_option('dingtalk')
+    page.locator('#bindingWebhookSaveBtn').click()
+    expect(page.locator('#bindingSaveStatus')).to_contain_text('重新填写')
+    assert len(updates) == 1
+    page.locator('#bindingWebhookClearBtn').click()
+    page.locator('#bindingWebhookSaveBtn').click()
+    expect(page.locator('#bindingWebhookSaveStatus')).to_contain_text('已保存')
+    assert updates[-1]['notification_webhook'] == {'clear': True}
+    page.locator('#closeBindingDialogBtn').click()
+    page.mouse.move(page.viewport_size['width'] - 1, page.viewport_size['height'] - 1)
+    page.keyboard.press('Escape')
+    page.locator('#openBindingDialogBtn').click()
+    expect(page.locator('#bindingWebhookEnabled')).not_to_be_checked()
+    expect(page.locator('#bindingWebhookUrl')).to_have_value('')
+    page.locator('#bindingWebhookEnabled').check()
+    page.locator('#bindingWebhookSettings').scroll_into_view_if_needed()
+    page.screenshot(path=str(tmp_path / 'binding-webhook.png'))
+    assert page.locator('#bindingWebhookSettings').evaluate('node => node.scrollWidth <= node.clientWidth')
+    assert page.locator('#bindingDialogOverlay .binding-dialog').evaluate('node => node.scrollWidth <= node.clientWidth')
+    assert not errors
+
+
+def test_notification_docs_are_discoverable_and_examples_match_sdk(page, frontend_url):
+    requests, errors = open_bindings(page, frontend_url)
+    page.locator('.nav-item[data-view="api"]').click()
+    group = page.locator('[data-api-group="system"]')
+    if group.get_attribute('aria-expanded') != 'true':
+        group.click()
+    page.locator('[data-endpoint-id="notification_send"]').click()
+    docs = page.locator('#apiDocDetail')
+    expect(docs).to_contain_text('资金账号字符串')
+    code = docs.locator('pre[data-language="python"]').inner_text()
+    for call in (node for node in ast.walk(ast.parse(code)) if isinstance(node, ast.Call)):
+        if isinstance(call.func, ast.Attribute) and call.func.attr == 'send':
+            inspect.signature(notify.send).bind(*[None for _ in call.args], **{kw.arg: None for kw in call.keywords})
+    page.locator('[data-api-sdk-tutorial]').click()
+    expect(page.locator('.python-document-head h2')).to_have_text('send')
+    expect(page.locator('.python-breadcrumb')).to_contain_text('消息推送')
+    assert page.locator('[data-python-cftrader-guide]').count() == 0
+    assert all(method == 'GET' for method, path in requests)
+    assert not errors

cfquant-0.2.68/cfquant/tests/test_history_download_memory.py

@@ -0,0 +1,68 @@
+"""Regression checks for bounded historical download requests."""
+
+from types import SimpleNamespace
+
+from cfquant.qmt_bridge import CfquantQmtBridge
+from cfquant.tx_trade_bridge import TxTradeBridge
+
+
+def _run_download(bridge_cls):
+    calls = []
+    events = []
+
+    def download(stock_list, period, start_time, end_time, callback, incrementally):
+        calls.append((list(stock_list), period, start_time, end_time, incrementally))
+        for index, stock_code in enumerate(stock_list, 1):
+            callback({
+                "finished": index,
+                "total": len(stock_list),
+                "stockcode": stock_code,
+                "message": "",
+            })
+
+    bridge = bridge_cls(
+        SimpleNamespace(),
+        show=False,
+        globals_dict={"download_history_data2": download},
+    )
+    bridge._send_event = lambda client, event, data, **kwargs: events.append((event, data, kwargs))
+    result = bridge._download_history_data2({
+        "stock_list": ["000001.SZ", "000002.SZ", "000003.SZ", "000004.SZ", "000005.SZ"],
+        "period": "1m",
+        "callback_event": "download:history",
+        "download_emit_lifecycle": True,
+        "download_batch_size": 2,
+        "incrementally": True,
+    }, {"client_id": "client-1"})
+    return result, calls, events
+
+
+def test_tx_trade_history_download_is_serially_batched_and_progress_is_aggregated():
+    result, calls, events = _run_download(TxTradeBridge)
+
+    assert result is None
+    assert [call[0] for call in calls] == [
+        ["000001.SZ", "000002.SZ"],
+        ["000003.SZ", "000004.SZ"],
+        ["000005.SZ"],
+    ]
+    progress = [data for _, data, meta in events if meta["meta"]["stage"] == "progress"]
+    assert progress[-1]["finished"] == 5
+    assert progress[-1]["total"] == 5
+    request_done = [data for _, data, meta in events if meta["meta"]["stage"] == "request_done"]
+    assert len(request_done) == 1
+    assert request_done[0]["finished"] == 5
+
+
+def test_legacy_qmt_bridge_uses_the_same_download_guard():
+    _, calls, _ = _run_download(CfquantQmtBridge)
+    assert [call[0] for call in calls] == [
+        ["000001.SZ", "000002.SZ"],
+        ["000003.SZ", "000004.SZ"],
+        ["000005.SZ"],
+    ]
+
+
+def test_minute_download_defaults_to_a_small_batch():
+    assert TxTradeBridge._history_download_batch_size({"period": "1m"}) == 50
+    assert TxTradeBridge._history_download_batch_size({"period": "1d"}) == 200